(function () {

function $parcel$export(e, n, v, s) {
  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
}

      var $parcel$global =
        typeof globalThis !== 'undefined'
          ? globalThis
          : typeof self !== 'undefined'
          ? self
          : typeof window !== 'undefined'
          ? window
          : typeof global !== 'undefined'
          ? global
          : {};
  
var $parcel$modules = {};
var $parcel$inits = {};

var parcelRequire = $parcel$global["parcelRequire94c2"];

if (parcelRequire == null) {
  parcelRequire = function(id) {
    if (id in $parcel$modules) {
      return $parcel$modules[id].exports;
    }
    if (id in $parcel$inits) {
      var init = $parcel$inits[id];
      delete $parcel$inits[id];
      var module = {id: id, exports: {}};
      $parcel$modules[id] = module;
      init.call(module.exports, module, module.exports);
      return module.exports;
    }
    var err = new Error("Cannot find module '" + id + "'");
    err.code = 'MODULE_NOT_FOUND';
    throw err;
  };

  parcelRequire.register = function register(id, init) {
    $parcel$inits[id] = init;
  };

  $parcel$global["parcelRequire94c2"] = parcelRequire;
}

var parcelRegister = parcelRequire.register;
parcelRegister("9xqYB", function(module, exports) {

$parcel$export(module.exports, "register", function () { return $6f1c1f1b2dada3ed$export$6503ec6e8aabbaf; }, function (v) { return $6f1c1f1b2dada3ed$export$6503ec6e8aabbaf = v; });
var $6f1c1f1b2dada3ed$export$6503ec6e8aabbaf;
var $6f1c1f1b2dada3ed$export$f7ad0328861e2f03;
"use strict";
var $6f1c1f1b2dada3ed$var$mapping = new Map();
function $6f1c1f1b2dada3ed$var$register(baseUrl, manifest) {
    for(var i = 0; i < manifest.length - 1; i += 2)$6f1c1f1b2dada3ed$var$mapping.set(manifest[i], {
        baseUrl: baseUrl,
        path: manifest[i + 1]
    });
}
function $6f1c1f1b2dada3ed$var$resolve(id) {
    var resolved = $6f1c1f1b2dada3ed$var$mapping.get(id);
    if (resolved == null) throw new Error('Could not resolve bundle with id ' + id);
    return new URL(resolved.path, resolved.baseUrl).toString();
}
$6f1c1f1b2dada3ed$export$6503ec6e8aabbaf = $6f1c1f1b2dada3ed$var$register;
$6f1c1f1b2dada3ed$export$f7ad0328861e2f03 = $6f1c1f1b2dada3ed$var$resolve;

});

parcelRegister("cHmwT", function(module, exports) {

$parcel$export(module.exports, "getBundleURL", function () { return $93eafa1434f2e08a$export$bdfd709ae4826697; }, function (v) { return $93eafa1434f2e08a$export$bdfd709ae4826697 = v; });
var $93eafa1434f2e08a$export$bdfd709ae4826697;
var $93eafa1434f2e08a$export$c9e73fbda7da57b6;
var $93eafa1434f2e08a$export$5a759dc7a1cfb72a;
"use strict";
var $93eafa1434f2e08a$var$bundleURL = {};
function $93eafa1434f2e08a$var$getBundleURLCached(id) {
    var value = $93eafa1434f2e08a$var$bundleURL[id];
    if (!value) {
        value = $93eafa1434f2e08a$var$getBundleURL();
        $93eafa1434f2e08a$var$bundleURL[id] = value;
    }
    return value;
}
function $93eafa1434f2e08a$var$getBundleURL() {
    try {
        throw new Error();
    } catch (err) {
        var matches = ('' + err.stack).match(/(https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/[^)\n]+/g);
        if (matches) // The first two stack frames will be this function and getBundleURLCached.
        // Use the 3rd one, which will be a runtime in the original bundle.
        return $93eafa1434f2e08a$var$getBaseURL(matches[2]);
    }
    return '/';
}
function $93eafa1434f2e08a$var$getBaseURL(url) {
    return ('' + url).replace(/^((?:https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/.+)\/[^/]+$/, '$1') + '/';
}
// TODO: Replace uses with `new URL(url).origin` when ie11 is no longer supported.
function $93eafa1434f2e08a$var$getOrigin(url) {
    var matches = ('' + url).match(/(https?|file|ftp|(chrome|moz|safari-web)-extension):\/\/[^/]+/);
    if (!matches) throw new Error('Origin not found');
    return matches[0];
}
$93eafa1434f2e08a$export$bdfd709ae4826697 = $93eafa1434f2e08a$var$getBundleURLCached;
$93eafa1434f2e08a$export$c9e73fbda7da57b6 = $93eafa1434f2e08a$var$getBaseURL;
$93eafa1434f2e08a$export$5a759dc7a1cfb72a = $93eafa1434f2e08a$var$getOrigin;

});

var $8e04579807b546a2$exports = {};


(parcelRequire("9xqYB")).register((parcelRequire("cHmwT")).getBundleURL('jU3hC'), JSON.parse("[\"jU3hC\",\"index.5fbba999.js\",\"dgcPj\",\"homegrown-1.d8782a51.png\",\"cFyH0\",\"homegrown-4.65054a77.png\",\"2nSE5\",\"homegrown-6.b1ebcf6f.png\",\"6Fwzv\",\"valueprop-icon-check.62708038.png\",\"chfVm\",\"hippo.547697ff.png\",\"j6qnU\",\"star1.0e395a85.png\",\"bxnvk\",\"star2.dad2fd56.png\",\"iz1Nc\",\"star3.63fbb0ab.png\"]"));

// import * as THREE from "three/build/three.webgpu.js"
/**
 * @license
 * Copyright 2010-2024 Three.js Authors
 * SPDX-License-Identifier: MIT
 */ /**
 * @license
 * Copyright 2010-2024 Three.js Authors
 * SPDX-License-Identifier: MIT
 */ const $d5b85d29c0b78636$export$3545e07a80636437 = '172';
const $d5b85d29c0b78636$export$7177b3e430c2d7ca = {
    LEFT: 0,
    MIDDLE: 1,
    RIGHT: 2,
    ROTATE: 0,
    DOLLY: 1,
    PAN: 2
};
const $d5b85d29c0b78636$export$d46bd3ead7cc759b = {
    ROTATE: 0,
    PAN: 1,
    DOLLY_PAN: 2,
    DOLLY_ROTATE: 3
};
const $d5b85d29c0b78636$export$3237e1f2c1ea1f44 = 0;
const $d5b85d29c0b78636$export$b9a7b4fc5cb15f9b = 1;
const $d5b85d29c0b78636$export$b8058bcc7037d3f3 = 2;
const $d5b85d29c0b78636$export$f24be24dcddeac0d = 3;
const $d5b85d29c0b78636$export$346307dbae2b7447 = 0;
const $d5b85d29c0b78636$export$5813f879eee7cd88 = 1;
const $d5b85d29c0b78636$export$a47c4b43a1be34f0 = 2;
const $d5b85d29c0b78636$export$896ae1ade6c829c4 = 3;
const $d5b85d29c0b78636$export$2ede184fc2998901 = 0;
const $d5b85d29c0b78636$export$d9f0486e75b5ace = 1;
const $d5b85d29c0b78636$export$3b296b6f144d5b03 = 2;
const $d5b85d29c0b78636$export$63b8d6b580fc65ba = 0;
const $d5b85d29c0b78636$export$5b29a26d96ee6af0 = 1;
const $d5b85d29c0b78636$export$777d8f9551c2216b = 2;
const $d5b85d29c0b78636$export$cdfa06f868e2e467 = 3;
const $d5b85d29c0b78636$export$4138e1c684b46a20 = 4;
const $d5b85d29c0b78636$export$eda4864c68df1fa2 = 5;
const $d5b85d29c0b78636$export$20183a0484ce21a0 = 100;
const $d5b85d29c0b78636$export$73e0df5177988548 = 101;
const $d5b85d29c0b78636$export$28e582859cbec660 = 102;
const $d5b85d29c0b78636$export$c8c1508da8d0600c = 103;
const $d5b85d29c0b78636$export$99948c02fb51055f = 104;
const $d5b85d29c0b78636$export$2110f05edf778d3d = 200;
const $d5b85d29c0b78636$export$8805bad65e24940e = 201;
const $d5b85d29c0b78636$export$7fbe15b28d28cf52 = 202;
const $d5b85d29c0b78636$export$947829af9f2c17f6 = 203;
const $d5b85d29c0b78636$export$d5773124e86cf28c = 204;
const $d5b85d29c0b78636$export$11d468cc7f19e971 = 205;
const $d5b85d29c0b78636$export$a78aed1ca2a87192 = 206;
const $d5b85d29c0b78636$export$5d0fe17fd8773bac = 207;
const $d5b85d29c0b78636$export$ef5f2dd8ffac5574 = 208;
const $d5b85d29c0b78636$export$56b85b2686ab16 = 209;
const $d5b85d29c0b78636$export$c05e2a1fc8609506 = 210;
const $d5b85d29c0b78636$export$7dd8f434fd59075 = 211;
const $d5b85d29c0b78636$export$99c8d898a9afbcee = 212;
const $d5b85d29c0b78636$export$310cd2be38d13b56 = 213;
const $d5b85d29c0b78636$export$db77b8fbcf45dbf4 = 214;
const $d5b85d29c0b78636$export$69025ce147cee220 = 0;
const $d5b85d29c0b78636$export$7182eb52ea3b3f04 = 1;
const $d5b85d29c0b78636$export$eedccec66ab7ebe = 2;
const $d5b85d29c0b78636$export$296f78a0b892f81a = 3;
const $d5b85d29c0b78636$export$a60d398fc7b7590e = 4;
const $d5b85d29c0b78636$export$7d7234c1240a1fc4 = 5;
const $d5b85d29c0b78636$export$c5e2c52991f30937 = 6;
const $d5b85d29c0b78636$export$2f843afa843d8916 = 7;
const $d5b85d29c0b78636$export$e50ac29801f1774d = 0;
const $d5b85d29c0b78636$export$9f9d94f963c85479 = 1;
const $d5b85d29c0b78636$export$e641dc52bc3494aa = 2;
const $d5b85d29c0b78636$export$9fcb6b4294603b2 = 0;
const $d5b85d29c0b78636$export$98f52c2a46c598ca = 1;
const $d5b85d29c0b78636$export$74b25e54b3bcd548 = 2;
const $d5b85d29c0b78636$export$932b3dd283d4a366 = 3;
const $d5b85d29c0b78636$export$a0d98fe6d7e4af64 = 4;
const $d5b85d29c0b78636$export$2c7b09c1e9abfb5e = 5;
const $d5b85d29c0b78636$export$212d53a513a325b2 = 6;
const $d5b85d29c0b78636$export$f2863e1668a8e317 = 7;
const $d5b85d29c0b78636$export$2595a3798997538 = 'attached';
const $d5b85d29c0b78636$export$d7e7dc2e114517a0 = 'detached';
const $d5b85d29c0b78636$export$1beec6768cbb3d2d = 300;
const $d5b85d29c0b78636$export$8759762a6477f2c4 = 301;
const $d5b85d29c0b78636$export$dc59f8aed047f61d = 302;
const $d5b85d29c0b78636$export$d64030b316d3b087 = 303;
const $d5b85d29c0b78636$export$ee99d97d46898098 = 304;
const $d5b85d29c0b78636$export$dbf3e70ff37af79 = 306;
const $d5b85d29c0b78636$export$533346c8e8dac0f5 = 1000;
const $d5b85d29c0b78636$export$9d9334239a5a5e06 = 1001;
const $d5b85d29c0b78636$export$c7e7c00b14f51a4f = 1002;
const $d5b85d29c0b78636$export$727aa5ec3fe39bf0 = 1003;
const $d5b85d29c0b78636$export$d129e38cf6feaa8c = 1004;
const $d5b85d29c0b78636$export$14a4936464a36496 = 1004;
const $d5b85d29c0b78636$export$d2327c1afe5bfdf2 = 1005;
const $d5b85d29c0b78636$export$cbc5b7f5647595d8 = 1005;
const $d5b85d29c0b78636$export$8a72f490b25c56c8 = 1006;
const $d5b85d29c0b78636$export$19a719f377145a13 = 1007;
const $d5b85d29c0b78636$export$dbe96bee3fe9dbf0 = 1007;
const $d5b85d29c0b78636$export$5d8599b6a933fb1b = 1008;
const $d5b85d29c0b78636$export$90d80f1e3506775f = 1008;
const $d5b85d29c0b78636$export$2e8ce08d3f6f5e10 = 1009;
const $d5b85d29c0b78636$export$545fce0311a9796a = 1010;
const $d5b85d29c0b78636$export$88572337f312435f = 1011;
const $d5b85d29c0b78636$export$c63dc51868b06a9d = 1012;
const $d5b85d29c0b78636$export$5c612977753abe2 = 1013;
const $d5b85d29c0b78636$export$c3c7fc4518ebba96 = 1014;
const $d5b85d29c0b78636$export$f6d331659b644596 = 1015;
const $d5b85d29c0b78636$export$2697304443f382bc = 1016;
const $d5b85d29c0b78636$export$b3969b01faf587f2 = 1017;
const $d5b85d29c0b78636$export$18886f8ae33e90de = 1018;
const $d5b85d29c0b78636$export$6c8ea339bfab1301 = 1020;
const $d5b85d29c0b78636$export$5a4c329b7e2092d3 = 35902;
const $d5b85d29c0b78636$export$988473390501ed4b = 1021;
const $d5b85d29c0b78636$export$7c67423a5ee6f5eb = 1022;
const $d5b85d29c0b78636$export$3f8bb04b555a363c = 1023;
const $d5b85d29c0b78636$export$cc09ccbf6d1ed449 = 1024;
const $d5b85d29c0b78636$export$9053a81c4a69c289 = 1025;
const $d5b85d29c0b78636$export$c1b6b5136be58045 = 1026;
const $d5b85d29c0b78636$export$1e113ac2d0905829 = 1027;
const $d5b85d29c0b78636$export$4e041a7967d15c4b = 1028;
const $d5b85d29c0b78636$export$aa92e870a709d190 = 1029;
const $d5b85d29c0b78636$export$6cdf0b461c7ce8a0 = 1030;
const $d5b85d29c0b78636$export$1ba1c45f9f77d4d7 = 1031;
const $d5b85d29c0b78636$export$d1fd40c11bfa798e = 1032;
const $d5b85d29c0b78636$export$c200e7d26f592f21 = 1033;
const $d5b85d29c0b78636$export$21d1799c6d552fc0 = 33776;
const $d5b85d29c0b78636$export$afa304c3e981b668 = 33777;
const $d5b85d29c0b78636$export$d2a1a68024a3e56c = 33778;
const $d5b85d29c0b78636$export$9a79c424327dacf9 = 33779;
const $d5b85d29c0b78636$export$19ada9bbb1af3573 = 35840;
const $d5b85d29c0b78636$export$d0f0355bb3d948e4 = 35841;
const $d5b85d29c0b78636$export$b82296714358084c = 35842;
const $d5b85d29c0b78636$export$b71692456c47b6c3 = 35843;
const $d5b85d29c0b78636$export$6ab91af2d757aee7 = 36196;
const $d5b85d29c0b78636$export$7800993ef8106a6a = 37492;
const $d5b85d29c0b78636$export$23ed8300a860e7d8 = 37496;
const $d5b85d29c0b78636$export$dc5570b4a2b92d48 = 37808;
const $d5b85d29c0b78636$export$68880cd325f8b2fb = 37809;
const $d5b85d29c0b78636$export$7d2c0be323373d95 = 37810;
const $d5b85d29c0b78636$export$22b52da301fc3a3e = 37811;
const $d5b85d29c0b78636$export$c009e2cb4a66485e = 37812;
const $d5b85d29c0b78636$export$118fff5afa255b63 = 37813;
const $d5b85d29c0b78636$export$120713c829ae0667 = 37814;
const $d5b85d29c0b78636$export$c79eeabbf53313e9 = 37815;
const $d5b85d29c0b78636$export$443cf6567cdd6424 = 37816;
const $d5b85d29c0b78636$export$6573984fc9840780 = 37817;
const $d5b85d29c0b78636$export$e7aee563f30091de = 37818;
const $d5b85d29c0b78636$export$2eb8634622ddeab7 = 37819;
const $d5b85d29c0b78636$export$202b1ce7b5d25742 = 37820;
const $d5b85d29c0b78636$export$18ab77abd087e467 = 37821;
const $d5b85d29c0b78636$export$ce40b115e188bc81 = 36492;
const $d5b85d29c0b78636$export$d279c5c4bac5121e = 36494;
const $d5b85d29c0b78636$export$cde52d17225fdbd3 = 36495;
const $d5b85d29c0b78636$export$b1688df4c4c21670 = 36283;
const $d5b85d29c0b78636$export$fc15e5d8261eed58 = 36284;
const $d5b85d29c0b78636$export$d220f6ade8463a0f = 36285;
const $d5b85d29c0b78636$export$768646d09dc1b6ef = 36286;
const $d5b85d29c0b78636$export$d62fdc9d1b1cccad = 2200;
const $d5b85d29c0b78636$export$dfaf4422ce096e29 = 2201;
const $d5b85d29c0b78636$export$f8f6f2041b78e210 = 2202;
const $d5b85d29c0b78636$export$995b32462a65e855 = 2300;
const $d5b85d29c0b78636$export$30fac1aace31cf4d = 2301;
const $d5b85d29c0b78636$export$198b11ff4c72bb30 = 2302;
const $d5b85d29c0b78636$export$7f795934b84ab523 = 2400;
const $d5b85d29c0b78636$export$24a4ccb5099273b5 = 2401;
const $d5b85d29c0b78636$export$8e8c3ecdcd8e1fee = 2402;
const $d5b85d29c0b78636$export$bcfbbdcf8de7f8cd = 2500;
const $d5b85d29c0b78636$export$d875e029ef558d3 = 2501;
const $d5b85d29c0b78636$export$4c28c87c2dc84758 = 0;
const $d5b85d29c0b78636$export$b23a071aa286eb29 = 1;
const $d5b85d29c0b78636$export$f0d8293634f88842 = 2;
const $d5b85d29c0b78636$export$deeb383078690b50 = 3200;
const $d5b85d29c0b78636$export$8f910f4c4f73df11 = 3201;
const $d5b85d29c0b78636$export$be2e2ddbc3983173 = 3202;
const $d5b85d29c0b78636$export$1a54198784742f80 = 3203;
const $d5b85d29c0b78636$export$2852a58ebdac27b8 = 0;
const $d5b85d29c0b78636$export$9990ad26f9db5b2c = 1;
// Color space string identifiers, matching CSS Color Module Level 4 and WebGPU names where available.
const $d5b85d29c0b78636$export$bfcb490c2dd3db51 = '';
const $d5b85d29c0b78636$export$561f394b24edfcaa = 'srgb';
const $d5b85d29c0b78636$export$42429b3acfb233a4 = 'srgb-linear';
const $d5b85d29c0b78636$export$f197347d588c1b4a = 'linear';
const $d5b85d29c0b78636$export$8d0a61916cc26abb = 'srgb';
const $d5b85d29c0b78636$export$69433f11f42d5527 = 0;
const $d5b85d29c0b78636$export$9f542ae4b5baca34 = 7680;
const $d5b85d29c0b78636$export$8a4f28336ef203d3 = 7681;
const $d5b85d29c0b78636$export$2928c0231297c036 = 7682;
const $d5b85d29c0b78636$export$c0e9611c8a15f9a8 = 7683;
const $d5b85d29c0b78636$export$9c2c08927385dcc4 = 34055;
const $d5b85d29c0b78636$export$7c74ea00fa1315e6 = 34056;
const $d5b85d29c0b78636$export$22e2e5726612443 = 5386;
const $d5b85d29c0b78636$export$1343870698229224 = 512;
const $d5b85d29c0b78636$export$8e1d8ed281997fa6 = 513;
const $d5b85d29c0b78636$export$55648a1cde8329a7 = 514;
const $d5b85d29c0b78636$export$2dff107857e6aca2 = 515;
const $d5b85d29c0b78636$export$6f93765ab2f451a2 = 516;
const $d5b85d29c0b78636$export$6f3fb2d2440f2b76 = 517;
const $d5b85d29c0b78636$export$4119cf7b4c98fd5a = 518;
const $d5b85d29c0b78636$export$14cf96713ddd97a8 = 519;
const $d5b85d29c0b78636$export$d9e2d19a747baaab = 512;
const $d5b85d29c0b78636$export$36bcf49c713b3eb7 = 513;
const $d5b85d29c0b78636$export$66f28d946fc6a0d5 = 514;
const $d5b85d29c0b78636$export$64eea11eb407ddf1 = 515;
const $d5b85d29c0b78636$export$155af022118f3a38 = 516;
const $d5b85d29c0b78636$export$67ab95dde6bed156 = 517;
const $d5b85d29c0b78636$export$1cdcb70d53d65f61 = 518;
const $d5b85d29c0b78636$export$187b73a3e352c145 = 519;
const $d5b85d29c0b78636$export$763e8360f4d7f77d = 35044;
const $d5b85d29c0b78636$export$8505d14ac8546ca = 35048;
const $d5b85d29c0b78636$export$721e63549e51d81e = 35040;
const $d5b85d29c0b78636$export$415731dc4f48e299 = 35045;
const $d5b85d29c0b78636$export$9e809946455f13bc = 35049;
const $d5b85d29c0b78636$export$2ed9499a35b5f832 = 35041;
const $d5b85d29c0b78636$export$32ab2503ea19469a = 35046;
const $d5b85d29c0b78636$export$ab4022c2c3f86315 = 35050;
const $d5b85d29c0b78636$export$ba7f1db36a76a970 = 35042;
const $d5b85d29c0b78636$export$43600cc67fabd9f = '100';
const $d5b85d29c0b78636$export$f63012db5506e7dd = '300 es';
const $d5b85d29c0b78636$export$5a0e9190d10875d3 = 2000;
const $d5b85d29c0b78636$export$cc83beedcb9be9ac = 2001;
/**
 * https://github.com/mrdoob/eventdispatcher.js/
 */ class $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    addEventListener(type, listener) {
        if (this._listeners === undefined) this._listeners = {};
        const listeners = this._listeners;
        if (listeners[type] === undefined) listeners[type] = [];
        if (listeners[type].indexOf(listener) === -1) listeners[type].push(listener);
    }
    hasEventListener(type, listener) {
        if (this._listeners === undefined) return false;
        const listeners = this._listeners;
        return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1;
    }
    removeEventListener(type, listener) {
        if (this._listeners === undefined) return;
        const listeners = this._listeners;
        const listenerArray = listeners[type];
        if (listenerArray !== undefined) {
            const index = listenerArray.indexOf(listener);
            if (index !== -1) listenerArray.splice(index, 1);
        }
    }
    dispatchEvent(event) {
        if (this._listeners === undefined) return;
        const listeners = this._listeners;
        const listenerArray = listeners[event.type];
        if (listenerArray !== undefined) {
            event.target = this;
            // Make a copy, in case listeners are removed while iterating.
            const array = listenerArray.slice(0);
            for(let i = 0, l = array.length; i < l; i++)array[i].call(this, event);
            event.target = null;
        }
    }
}
const $d5b85d29c0b78636$var$_lut = [
    '00',
    '01',
    '02',
    '03',
    '04',
    '05',
    '06',
    '07',
    '08',
    '09',
    '0a',
    '0b',
    '0c',
    '0d',
    '0e',
    '0f',
    '10',
    '11',
    '12',
    '13',
    '14',
    '15',
    '16',
    '17',
    '18',
    '19',
    '1a',
    '1b',
    '1c',
    '1d',
    '1e',
    '1f',
    '20',
    '21',
    '22',
    '23',
    '24',
    '25',
    '26',
    '27',
    '28',
    '29',
    '2a',
    '2b',
    '2c',
    '2d',
    '2e',
    '2f',
    '30',
    '31',
    '32',
    '33',
    '34',
    '35',
    '36',
    '37',
    '38',
    '39',
    '3a',
    '3b',
    '3c',
    '3d',
    '3e',
    '3f',
    '40',
    '41',
    '42',
    '43',
    '44',
    '45',
    '46',
    '47',
    '48',
    '49',
    '4a',
    '4b',
    '4c',
    '4d',
    '4e',
    '4f',
    '50',
    '51',
    '52',
    '53',
    '54',
    '55',
    '56',
    '57',
    '58',
    '59',
    '5a',
    '5b',
    '5c',
    '5d',
    '5e',
    '5f',
    '60',
    '61',
    '62',
    '63',
    '64',
    '65',
    '66',
    '67',
    '68',
    '69',
    '6a',
    '6b',
    '6c',
    '6d',
    '6e',
    '6f',
    '70',
    '71',
    '72',
    '73',
    '74',
    '75',
    '76',
    '77',
    '78',
    '79',
    '7a',
    '7b',
    '7c',
    '7d',
    '7e',
    '7f',
    '80',
    '81',
    '82',
    '83',
    '84',
    '85',
    '86',
    '87',
    '88',
    '89',
    '8a',
    '8b',
    '8c',
    '8d',
    '8e',
    '8f',
    '90',
    '91',
    '92',
    '93',
    '94',
    '95',
    '96',
    '97',
    '98',
    '99',
    '9a',
    '9b',
    '9c',
    '9d',
    '9e',
    '9f',
    'a0',
    'a1',
    'a2',
    'a3',
    'a4',
    'a5',
    'a6',
    'a7',
    'a8',
    'a9',
    'aa',
    'ab',
    'ac',
    'ad',
    'ae',
    'af',
    'b0',
    'b1',
    'b2',
    'b3',
    'b4',
    'b5',
    'b6',
    'b7',
    'b8',
    'b9',
    'ba',
    'bb',
    'bc',
    'bd',
    'be',
    'bf',
    'c0',
    'c1',
    'c2',
    'c3',
    'c4',
    'c5',
    'c6',
    'c7',
    'c8',
    'c9',
    'ca',
    'cb',
    'cc',
    'cd',
    'ce',
    'cf',
    'd0',
    'd1',
    'd2',
    'd3',
    'd4',
    'd5',
    'd6',
    'd7',
    'd8',
    'd9',
    'da',
    'db',
    'dc',
    'dd',
    'de',
    'df',
    'e0',
    'e1',
    'e2',
    'e3',
    'e4',
    'e5',
    'e6',
    'e7',
    'e8',
    'e9',
    'ea',
    'eb',
    'ec',
    'ed',
    'ee',
    'ef',
    'f0',
    'f1',
    'f2',
    'f3',
    'f4',
    'f5',
    'f6',
    'f7',
    'f8',
    'f9',
    'fa',
    'fb',
    'fc',
    'fd',
    'fe',
    'ff'
];
let $d5b85d29c0b78636$var$_seed = 1234567;
const $d5b85d29c0b78636$var$DEG2RAD = Math.PI / 180;
const $d5b85d29c0b78636$export$914076c8150813e5 = 180 / Math.PI;
// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
function $d5b85d29c0b78636$var$generateUUID() {
    const d0 = Math.random() * 0xffffffff | 0;
    const d1 = Math.random() * 0xffffffff | 0;
    const d2 = Math.random() * 0xffffffff | 0;
    const d3 = Math.random() * 0xffffffff | 0;
    const uuid = $d5b85d29c0b78636$var$_lut[d0 & 0xff] + $d5b85d29c0b78636$var$_lut[d0 >> 8 & 0xff] + $d5b85d29c0b78636$var$_lut[d0 >> 16 & 0xff] + $d5b85d29c0b78636$var$_lut[d0 >> 24 & 0xff] + '-' + $d5b85d29c0b78636$var$_lut[d1 & 0xff] + $d5b85d29c0b78636$var$_lut[d1 >> 8 & 0xff] + '-' + $d5b85d29c0b78636$var$_lut[d1 >> 16 & 0x0f | 0x40] + $d5b85d29c0b78636$var$_lut[d1 >> 24 & 0xff] + '-' + $d5b85d29c0b78636$var$_lut[d2 & 0x3f | 0x80] + $d5b85d29c0b78636$var$_lut[d2 >> 8 & 0xff] + '-' + $d5b85d29c0b78636$var$_lut[d2 >> 16 & 0xff] + $d5b85d29c0b78636$var$_lut[d2 >> 24 & 0xff] + $d5b85d29c0b78636$var$_lut[d3 & 0xff] + $d5b85d29c0b78636$var$_lut[d3 >> 8 & 0xff] + $d5b85d29c0b78636$var$_lut[d3 >> 16 & 0xff] + $d5b85d29c0b78636$var$_lut[d3 >> 24 & 0xff];
    // .toLowerCase() here flattens concatenated strings to save heap memory space.
    return uuid.toLowerCase();
}
function $d5b85d29c0b78636$var$clamp(value, min, max) {
    return Math.max(min, Math.min(max, value));
}
// compute euclidean modulo of m % n
// https://en.wikipedia.org/wiki/Modulo_operation
function $d5b85d29c0b78636$var$euclideanModulo(n, m) {
    return (n % m + m) % m;
}
// Linear mapping from range <a1, a2> to range <b1, b2>
function $d5b85d29c0b78636$var$mapLinear(x, a1, a2, b1, b2) {
    return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
}
// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
function $d5b85d29c0b78636$var$inverseLerp(x, y, value) {
    if (x !== y) return (value - x) / (y - x);
    else return 0;
}
// https://en.wikipedia.org/wiki/Linear_interpolation
function $d5b85d29c0b78636$var$lerp(x, y, t) {
    return (1 - t) * x + t * y;
}
// http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
function $d5b85d29c0b78636$var$damp(x, y, lambda, dt) {
    return $d5b85d29c0b78636$var$lerp(x, y, 1 - Math.exp(-lambda * dt));
}
// https://www.desmos.com/calculator/vcsjnyz7x4
function $d5b85d29c0b78636$var$pingpong(x, length = 1) {
    return length - Math.abs($d5b85d29c0b78636$var$euclideanModulo(x, length * 2) - length);
}
// http://en.wikipedia.org/wiki/Smoothstep
function $d5b85d29c0b78636$var$smoothstep(x, min, max) {
    if (x <= min) return 0;
    if (x >= max) return 1;
    x = (x - min) / (max - min);
    return x * x * (3 - 2 * x);
}
function $d5b85d29c0b78636$var$smootherstep(x, min, max) {
    if (x <= min) return 0;
    if (x >= max) return 1;
    x = (x - min) / (max - min);
    return x * x * x * (x * (x * 6 - 15) + 10);
}
// Random integer from <low, high> interval
function $d5b85d29c0b78636$var$randInt(low, high) {
    return low + Math.floor(Math.random() * (high - low + 1));
}
// Random float from <low, high> interval
function $d5b85d29c0b78636$var$randFloat(low, high) {
    return low + Math.random() * (high - low);
}
// Random float from <-range/2, range/2> interval
function $d5b85d29c0b78636$var$randFloatSpread(range) {
    return range * (0.5 - Math.random());
}
// Deterministic pseudo-random float in the interval [ 0, 1 ]
function $d5b85d29c0b78636$var$seededRandom(s) {
    if (s !== undefined) $d5b85d29c0b78636$var$_seed = s;
    // Mulberry32 generator
    let t = $d5b85d29c0b78636$var$_seed += 0x6D2B79F5;
    t = Math.imul(t ^ t >>> 15, t | 1);
    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
}
function $d5b85d29c0b78636$var$degToRad(degrees) {
    return degrees * $d5b85d29c0b78636$var$DEG2RAD;
}
function $d5b85d29c0b78636$var$radToDeg(radians) {
    return radians * $d5b85d29c0b78636$export$914076c8150813e5;
}
function $d5b85d29c0b78636$var$isPowerOfTwo(value) {
    return (value & value - 1) === 0 && value !== 0;
}
function $d5b85d29c0b78636$var$ceilPowerOfTwo(value) {
    return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2));
}
function $d5b85d29c0b78636$var$floorPowerOfTwo(value) {
    return Math.pow(2, Math.floor(Math.log(value) / Math.LN2));
}
function $d5b85d29c0b78636$var$setQuaternionFromProperEuler(q, a, b, c, order) {
    // Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
    // rotations are applied to the axes in the order specified by 'order'
    // rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
    // angles are in radians
    const cos = Math.cos;
    const sin = Math.sin;
    const c2 = cos(b / 2);
    const s2 = sin(b / 2);
    const c13 = cos((a + c) / 2);
    const s13 = sin((a + c) / 2);
    const c1_3 = cos((a - c) / 2);
    const s1_3 = sin((a - c) / 2);
    const c3_1 = cos((c - a) / 2);
    const s3_1 = sin((c - a) / 2);
    switch(order){
        case 'XYX':
            q.set(c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13);
            break;
        case 'YZY':
            q.set(s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13);
            break;
        case 'ZXZ':
            q.set(s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13);
            break;
        case 'XZX':
            q.set(c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13);
            break;
        case 'YXY':
            q.set(s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13);
            break;
        case 'ZYZ':
            q.set(s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13);
            break;
        default:
            console.warn('THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order);
    }
}
function $d5b85d29c0b78636$var$denormalize(value, array) {
    switch(array.constructor){
        case Float32Array:
            return value;
        case Uint32Array:
            return value / 4294967295.0;
        case Uint16Array:
            return value / 65535.0;
        case Uint8Array:
            return value / 255.0;
        case Int32Array:
            return Math.max(value / 2147483647.0, -1);
        case Int16Array:
            return Math.max(value / 32767.0, -1);
        case Int8Array:
            return Math.max(value / 127.0, -1);
        default:
            throw new Error('Invalid component type.');
    }
}
function $d5b85d29c0b78636$var$normalize(value, array) {
    switch(array.constructor){
        case Float32Array:
            return value;
        case Uint32Array:
            return Math.round(value * 4294967295.0);
        case Uint16Array:
            return Math.round(value * 65535.0);
        case Uint8Array:
            return Math.round(value * 255.0);
        case Int32Array:
            return Math.round(value * 2147483647.0);
        case Int16Array:
            return Math.round(value * 32767.0);
        case Int8Array:
            return Math.round(value * 127.0);
        default:
            throw new Error('Invalid component type.');
    }
}
const $d5b85d29c0b78636$export$6a7ef315a0d1ef07 = {
    DEG2RAD: $d5b85d29c0b78636$var$DEG2RAD,
    RAD2DEG: $d5b85d29c0b78636$export$914076c8150813e5,
    generateUUID: $d5b85d29c0b78636$var$generateUUID,
    clamp: $d5b85d29c0b78636$var$clamp,
    euclideanModulo: $d5b85d29c0b78636$var$euclideanModulo,
    mapLinear: $d5b85d29c0b78636$var$mapLinear,
    inverseLerp: $d5b85d29c0b78636$var$inverseLerp,
    lerp: $d5b85d29c0b78636$var$lerp,
    damp: $d5b85d29c0b78636$var$damp,
    pingpong: $d5b85d29c0b78636$var$pingpong,
    smoothstep: $d5b85d29c0b78636$var$smoothstep,
    smootherstep: $d5b85d29c0b78636$var$smootherstep,
    randInt: $d5b85d29c0b78636$var$randInt,
    randFloat: $d5b85d29c0b78636$var$randFloat,
    randFloatSpread: $d5b85d29c0b78636$var$randFloatSpread,
    seededRandom: $d5b85d29c0b78636$var$seededRandom,
    degToRad: $d5b85d29c0b78636$var$degToRad,
    radToDeg: $d5b85d29c0b78636$var$radToDeg,
    isPowerOfTwo: $d5b85d29c0b78636$var$isPowerOfTwo,
    ceilPowerOfTwo: $d5b85d29c0b78636$var$ceilPowerOfTwo,
    floorPowerOfTwo: $d5b85d29c0b78636$var$floorPowerOfTwo,
    setQuaternionFromProperEuler: $d5b85d29c0b78636$var$setQuaternionFromProperEuler,
    normalize: $d5b85d29c0b78636$var$normalize,
    denormalize: $d5b85d29c0b78636$var$denormalize
};
class $d5b85d29c0b78636$export$c977b3e384af9ae1 {
    constructor(x = 0, y = 0){
        $d5b85d29c0b78636$export$c977b3e384af9ae1.prototype.isVector2 = true;
        this.x = x;
        this.y = y;
    }
    get width() {
        return this.x;
    }
    set width(value) {
        this.x = value;
    }
    get height() {
        return this.y;
    }
    set height(value) {
        this.y = value;
    }
    set(x, y) {
        this.x = x;
        this.y = y;
        return this;
    }
    setScalar(scalar) {
        this.x = scalar;
        this.y = scalar;
        return this;
    }
    setX(x) {
        this.x = x;
        return this;
    }
    setY(y) {
        this.y = y;
        return this;
    }
    setComponent(index, value) {
        switch(index){
            case 0:
                this.x = value;
                break;
            case 1:
                this.y = value;
                break;
            default:
                throw new Error('index is out of range: ' + index);
        }
        return this;
    }
    getComponent(index) {
        switch(index){
            case 0:
                return this.x;
            case 1:
                return this.y;
            default:
                throw new Error('index is out of range: ' + index);
        }
    }
    clone() {
        return new this.constructor(this.x, this.y);
    }
    copy(v) {
        this.x = v.x;
        this.y = v.y;
        return this;
    }
    add(v) {
        this.x += v.x;
        this.y += v.y;
        return this;
    }
    addScalar(s) {
        this.x += s;
        this.y += s;
        return this;
    }
    addVectors(a, b) {
        this.x = a.x + b.x;
        this.y = a.y + b.y;
        return this;
    }
    addScaledVector(v, s) {
        this.x += v.x * s;
        this.y += v.y * s;
        return this;
    }
    sub(v) {
        this.x -= v.x;
        this.y -= v.y;
        return this;
    }
    subScalar(s) {
        this.x -= s;
        this.y -= s;
        return this;
    }
    subVectors(a, b) {
        this.x = a.x - b.x;
        this.y = a.y - b.y;
        return this;
    }
    multiply(v) {
        this.x *= v.x;
        this.y *= v.y;
        return this;
    }
    multiplyScalar(scalar) {
        this.x *= scalar;
        this.y *= scalar;
        return this;
    }
    divide(v) {
        this.x /= v.x;
        this.y /= v.y;
        return this;
    }
    divideScalar(scalar) {
        return this.multiplyScalar(1 / scalar);
    }
    applyMatrix3(m) {
        const x = this.x, y = this.y;
        const e = m.elements;
        this.x = e[0] * x + e[3] * y + e[6];
        this.y = e[1] * x + e[4] * y + e[7];
        return this;
    }
    min(v) {
        this.x = Math.min(this.x, v.x);
        this.y = Math.min(this.y, v.y);
        return this;
    }
    max(v) {
        this.x = Math.max(this.x, v.x);
        this.y = Math.max(this.y, v.y);
        return this;
    }
    clamp(min, max) {
        // assumes min < max, componentwise
        this.x = $d5b85d29c0b78636$var$clamp(this.x, min.x, max.x);
        this.y = $d5b85d29c0b78636$var$clamp(this.y, min.y, max.y);
        return this;
    }
    clampScalar(minVal, maxVal) {
        this.x = $d5b85d29c0b78636$var$clamp(this.x, minVal, maxVal);
        this.y = $d5b85d29c0b78636$var$clamp(this.y, minVal, maxVal);
        return this;
    }
    clampLength(min, max) {
        const length = this.length();
        return this.divideScalar(length || 1).multiplyScalar($d5b85d29c0b78636$var$clamp(length, min, max));
    }
    floor() {
        this.x = Math.floor(this.x);
        this.y = Math.floor(this.y);
        return this;
    }
    ceil() {
        this.x = Math.ceil(this.x);
        this.y = Math.ceil(this.y);
        return this;
    }
    round() {
        this.x = Math.round(this.x);
        this.y = Math.round(this.y);
        return this;
    }
    roundToZero() {
        this.x = Math.trunc(this.x);
        this.y = Math.trunc(this.y);
        return this;
    }
    negate() {
        this.x = -this.x;
        this.y = -this.y;
        return this;
    }
    dot(v) {
        return this.x * v.x + this.y * v.y;
    }
    cross(v) {
        return this.x * v.y - this.y * v.x;
    }
    lengthSq() {
        return this.x * this.x + this.y * this.y;
    }
    length() {
        return Math.sqrt(this.x * this.x + this.y * this.y);
    }
    manhattanLength() {
        return Math.abs(this.x) + Math.abs(this.y);
    }
    normalize() {
        return this.divideScalar(this.length() || 1);
    }
    angle() {
        // computes the angle in radians with respect to the positive x-axis
        const angle = Math.atan2(-this.y, -this.x) + Math.PI;
        return angle;
    }
    angleTo(v) {
        const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
        if (denominator === 0) return Math.PI / 2;
        const theta = this.dot(v) / denominator;
        // clamp, to handle numerical problems
        return Math.acos($d5b85d29c0b78636$var$clamp(theta, -1, 1));
    }
    distanceTo(v) {
        return Math.sqrt(this.distanceToSquared(v));
    }
    distanceToSquared(v) {
        const dx = this.x - v.x, dy = this.y - v.y;
        return dx * dx + dy * dy;
    }
    manhattanDistanceTo(v) {
        return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
    }
    setLength(length) {
        return this.normalize().multiplyScalar(length);
    }
    lerp(v, alpha) {
        this.x += (v.x - this.x) * alpha;
        this.y += (v.y - this.y) * alpha;
        return this;
    }
    lerpVectors(v1, v2, alpha) {
        this.x = v1.x + (v2.x - v1.x) * alpha;
        this.y = v1.y + (v2.y - v1.y) * alpha;
        return this;
    }
    equals(v) {
        return v.x === this.x && v.y === this.y;
    }
    fromArray(array, offset = 0) {
        this.x = array[offset];
        this.y = array[offset + 1];
        return this;
    }
    toArray(array = [], offset = 0) {
        array[offset] = this.x;
        array[offset + 1] = this.y;
        return array;
    }
    fromBufferAttribute(attribute, index) {
        this.x = attribute.getX(index);
        this.y = attribute.getY(index);
        return this;
    }
    rotateAround(center, angle) {
        const c = Math.cos(angle), s = Math.sin(angle);
        const x = this.x - center.x;
        const y = this.y - center.y;
        this.x = x * c - y * s + center.x;
        this.y = x * s + y * c + center.y;
        return this;
    }
    random() {
        this.x = Math.random();
        this.y = Math.random();
        return this;
    }
    *[Symbol.iterator]() {
        yield this.x;
        yield this.y;
    }
}
class $d5b85d29c0b78636$export$8ff26dafa08918 {
    constructor(n11, n12, n13, n21, n22, n23, n31, n32, n33){
        $d5b85d29c0b78636$export$8ff26dafa08918.prototype.isMatrix3 = true;
        this.elements = [
            1,
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            1
        ];
        if (n11 !== undefined) this.set(n11, n12, n13, n21, n22, n23, n31, n32, n33);
    }
    set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
        const te = this.elements;
        te[0] = n11;
        te[1] = n21;
        te[2] = n31;
        te[3] = n12;
        te[4] = n22;
        te[5] = n32;
        te[6] = n13;
        te[7] = n23;
        te[8] = n33;
        return this;
    }
    identity() {
        this.set(1, 0, 0, 0, 1, 0, 0, 0, 1);
        return this;
    }
    copy(m) {
        const te = this.elements;
        const me = m.elements;
        te[0] = me[0];
        te[1] = me[1];
        te[2] = me[2];
        te[3] = me[3];
        te[4] = me[4];
        te[5] = me[5];
        te[6] = me[6];
        te[7] = me[7];
        te[8] = me[8];
        return this;
    }
    extractBasis(xAxis, yAxis, zAxis) {
        xAxis.setFromMatrix3Column(this, 0);
        yAxis.setFromMatrix3Column(this, 1);
        zAxis.setFromMatrix3Column(this, 2);
        return this;
    }
    setFromMatrix4(m) {
        const me = m.elements;
        this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10]);
        return this;
    }
    multiply(m) {
        return this.multiplyMatrices(this, m);
    }
    premultiply(m) {
        return this.multiplyMatrices(m, this);
    }
    multiplyMatrices(a, b) {
        const ae = a.elements;
        const be = b.elements;
        const te = this.elements;
        const a11 = ae[0], a12 = ae[3], a13 = ae[6];
        const a21 = ae[1], a22 = ae[4], a23 = ae[7];
        const a31 = ae[2], a32 = ae[5], a33 = ae[8];
        const b11 = be[0], b12 = be[3], b13 = be[6];
        const b21 = be[1], b22 = be[4], b23 = be[7];
        const b31 = be[2], b32 = be[5], b33 = be[8];
        te[0] = a11 * b11 + a12 * b21 + a13 * b31;
        te[3] = a11 * b12 + a12 * b22 + a13 * b32;
        te[6] = a11 * b13 + a12 * b23 + a13 * b33;
        te[1] = a21 * b11 + a22 * b21 + a23 * b31;
        te[4] = a21 * b12 + a22 * b22 + a23 * b32;
        te[7] = a21 * b13 + a22 * b23 + a23 * b33;
        te[2] = a31 * b11 + a32 * b21 + a33 * b31;
        te[5] = a31 * b12 + a32 * b22 + a33 * b32;
        te[8] = a31 * b13 + a32 * b23 + a33 * b33;
        return this;
    }
    multiplyScalar(s) {
        const te = this.elements;
        te[0] *= s;
        te[3] *= s;
        te[6] *= s;
        te[1] *= s;
        te[4] *= s;
        te[7] *= s;
        te[2] *= s;
        te[5] *= s;
        te[8] *= s;
        return this;
    }
    determinant() {
        const te = this.elements;
        const a = te[0], b = te[1], c = te[2], d = te[3], e = te[4], f = te[5], g = te[6], h = te[7], i = te[8];
        return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
    }
    invert() {
        const te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n12 = te[3], n22 = te[4], n32 = te[5], n13 = te[6], n23 = te[7], n33 = te[8], t11 = n33 * n22 - n32 * n23, t12 = n32 * n13 - n33 * n12, t13 = n23 * n12 - n22 * n13, det = n11 * t11 + n21 * t12 + n31 * t13;
        if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
        const detInv = 1 / det;
        te[0] = t11 * detInv;
        te[1] = (n31 * n23 - n33 * n21) * detInv;
        te[2] = (n32 * n21 - n31 * n22) * detInv;
        te[3] = t12 * detInv;
        te[4] = (n33 * n11 - n31 * n13) * detInv;
        te[5] = (n31 * n12 - n32 * n11) * detInv;
        te[6] = t13 * detInv;
        te[7] = (n21 * n13 - n23 * n11) * detInv;
        te[8] = (n22 * n11 - n21 * n12) * detInv;
        return this;
    }
    transpose() {
        let tmp;
        const m = this.elements;
        tmp = m[1];
        m[1] = m[3];
        m[3] = tmp;
        tmp = m[2];
        m[2] = m[6];
        m[6] = tmp;
        tmp = m[5];
        m[5] = m[7];
        m[7] = tmp;
        return this;
    }
    getNormalMatrix(matrix4) {
        return this.setFromMatrix4(matrix4).invert().transpose();
    }
    transposeIntoArray(r) {
        const m = this.elements;
        r[0] = m[0];
        r[1] = m[3];
        r[2] = m[6];
        r[3] = m[1];
        r[4] = m[4];
        r[5] = m[7];
        r[6] = m[2];
        r[7] = m[5];
        r[8] = m[8];
        return this;
    }
    setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
        const c = Math.cos(rotation);
        const s = Math.sin(rotation);
        this.set(sx * c, sx * s, -sx * (c * cx + s * cy) + cx + tx, -sy * s, sy * c, -sy * (-s * cx + c * cy) + cy + ty, 0, 0, 1);
        return this;
    }
    //
    scale(sx, sy) {
        this.premultiply($d5b85d29c0b78636$var$_m3.makeScale(sx, sy));
        return this;
    }
    rotate(theta) {
        this.premultiply($d5b85d29c0b78636$var$_m3.makeRotation(-theta));
        return this;
    }
    translate(tx, ty) {
        this.premultiply($d5b85d29c0b78636$var$_m3.makeTranslation(tx, ty));
        return this;
    }
    // for 2D Transforms
    makeTranslation(x, y) {
        if (x.isVector2) this.set(1, 0, x.x, 0, 1, x.y, 0, 0, 1);
        else this.set(1, 0, x, 0, 1, y, 0, 0, 1);
        return this;
    }
    makeRotation(theta) {
        // counterclockwise
        const c = Math.cos(theta);
        const s = Math.sin(theta);
        this.set(c, -s, 0, s, c, 0, 0, 0, 1);
        return this;
    }
    makeScale(x, y) {
        this.set(x, 0, 0, 0, y, 0, 0, 0, 1);
        return this;
    }
    //
    equals(matrix) {
        const te = this.elements;
        const me = matrix.elements;
        for(let i = 0; i < 9; i++){
            if (te[i] !== me[i]) return false;
        }
        return true;
    }
    fromArray(array, offset = 0) {
        for(let i = 0; i < 9; i++)this.elements[i] = array[i + offset];
        return this;
    }
    toArray(array = [], offset = 0) {
        const te = this.elements;
        array[offset] = te[0];
        array[offset + 1] = te[1];
        array[offset + 2] = te[2];
        array[offset + 3] = te[3];
        array[offset + 4] = te[4];
        array[offset + 5] = te[5];
        array[offset + 6] = te[6];
        array[offset + 7] = te[7];
        array[offset + 8] = te[8];
        return array;
    }
    clone() {
        return new this.constructor().fromArray(this.elements);
    }
}
const $d5b85d29c0b78636$var$_m3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$8ff26dafa08918();
function $d5b85d29c0b78636$export$bc6f937da07eae17(array) {
    // assumes larger values usually on last
    for(let i = array.length - 1; i >= 0; --i){
        if (array[i] >= 65535) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
    }
    return false;
}
const $d5b85d29c0b78636$var$TYPED_ARRAYS = {
    Int8Array: Int8Array,
    Uint8Array: Uint8Array,
    Uint8ClampedArray: Uint8ClampedArray,
    Int16Array: Int16Array,
    Uint16Array: Uint16Array,
    Int32Array: Int32Array,
    Uint32Array: Uint32Array,
    Float32Array: Float32Array,
    Float64Array: Float64Array
};
function $d5b85d29c0b78636$var$getTypedArray(type, buffer) {
    return new $d5b85d29c0b78636$var$TYPED_ARRAYS[type](buffer);
}
function $d5b85d29c0b78636$export$7094a064528c7fee(name) {
    return document.createElementNS('http://www.w3.org/1999/xhtml', name);
}
function $d5b85d29c0b78636$export$1033a2df66368859() {
    const canvas = $d5b85d29c0b78636$export$7094a064528c7fee('canvas');
    canvas.style.display = 'block';
    return canvas;
}
const $d5b85d29c0b78636$var$_cache = {};
function $d5b85d29c0b78636$export$5b28268982f175ba(message) {
    if (message in $d5b85d29c0b78636$var$_cache) return;
    $d5b85d29c0b78636$var$_cache[message] = true;
    console.warn(message);
}
function $d5b85d29c0b78636$export$d43f91ebeafb2c7(gl, sync, interval) {
    return new Promise(function(resolve, reject) {
        function probe() {
            switch(gl.clientWaitSync(sync, gl.SYNC_FLUSH_COMMANDS_BIT, 0)){
                case gl.WAIT_FAILED:
                    reject();
                    break;
                case gl.TIMEOUT_EXPIRED:
                    setTimeout(probe, interval);
                    break;
                default:
                    resolve();
            }
        }
        setTimeout(probe, interval);
    });
}
function $d5b85d29c0b78636$export$5238391f68c729b(projectionMatrix) {
    const m = projectionMatrix.elements;
    // Convert [-1, 1] to [0, 1] projection matrix
    m[2] = 0.5 * m[2] + 0.5 * m[3];
    m[6] = 0.5 * m[6] + 0.5 * m[7];
    m[10] = 0.5 * m[10] + 0.5 * m[11];
    m[14] = 0.5 * m[14] + 0.5 * m[15];
}
function $d5b85d29c0b78636$export$f8cf97d08da9bc86(projectionMatrix) {
    const m = projectionMatrix.elements;
    const isPerspectiveMatrix = m[11] === -1;
    // Reverse [0, 1] projection matrix
    if (isPerspectiveMatrix) {
        m[10] = -m[10] - 1;
        m[14] = -m[14];
    } else {
        m[10] = -m[10];
        m[14] = -m[14] + 1;
    }
}
const $d5b85d29c0b78636$var$LINEAR_REC709_TO_XYZ = /*@__PURE__*/ new $d5b85d29c0b78636$export$8ff26dafa08918().set(0.4123908, 0.3575843, 0.1804808, 0.2126390, 0.7151687, 0.0721923, 0.0193308, 0.1191948, 0.9505322);
const $d5b85d29c0b78636$var$XYZ_TO_LINEAR_REC709 = /*@__PURE__*/ new $d5b85d29c0b78636$export$8ff26dafa08918().set(3.2409699, -1.5373832, -0.4986108, -0.9692436, 1.8759675, 0.0415551, 0.0556301, -0.203977, 1.0569715);
function $d5b85d29c0b78636$var$createColorManagement() {
    const ColorManagement = {
        enabled: true,
        workingColorSpace: $d5b85d29c0b78636$export$42429b3acfb233a4,
        /**
		 * Implementations of supported color spaces.
		 *
		 * Required:
		 *	- primaries: chromaticity coordinates [ rx ry gx gy bx by ]
		 *	- whitePoint: reference white [ x y ]
		 *	- transfer: transfer function (pre-defined)
		 *	- toXYZ: Matrix3 RGB to XYZ transform
		 *	- fromXYZ: Matrix3 XYZ to RGB transform
		 *	- luminanceCoefficients: RGB luminance coefficients
		 *
		 * Optional:
		 *  - outputColorSpaceConfig: { drawingBufferColorSpace: ColorSpace }
		 *  - workingColorSpaceConfig: { unpackColorSpace: ColorSpace }
		 *
		 * Reference:
		 * - https://www.russellcottrell.com/photo/matrixCalculator.htm
		 */ spaces: {},
        convert: function(color, sourceColorSpace, targetColorSpace) {
            if (this.enabled === false || sourceColorSpace === targetColorSpace || !sourceColorSpace || !targetColorSpace) return color;
            if (this.spaces[sourceColorSpace].transfer === $d5b85d29c0b78636$export$8d0a61916cc26abb) {
                color.r = $d5b85d29c0b78636$var$SRGBToLinear(color.r);
                color.g = $d5b85d29c0b78636$var$SRGBToLinear(color.g);
                color.b = $d5b85d29c0b78636$var$SRGBToLinear(color.b);
            }
            if (this.spaces[sourceColorSpace].primaries !== this.spaces[targetColorSpace].primaries) {
                color.applyMatrix3(this.spaces[sourceColorSpace].toXYZ);
                color.applyMatrix3(this.spaces[targetColorSpace].fromXYZ);
            }
            if (this.spaces[targetColorSpace].transfer === $d5b85d29c0b78636$export$8d0a61916cc26abb) {
                color.r = $d5b85d29c0b78636$var$LinearToSRGB(color.r);
                color.g = $d5b85d29c0b78636$var$LinearToSRGB(color.g);
                color.b = $d5b85d29c0b78636$var$LinearToSRGB(color.b);
            }
            return color;
        },
        fromWorkingColorSpace: function(color, targetColorSpace) {
            return this.convert(color, this.workingColorSpace, targetColorSpace);
        },
        toWorkingColorSpace: function(color, sourceColorSpace) {
            return this.convert(color, sourceColorSpace, this.workingColorSpace);
        },
        getPrimaries: function(colorSpace) {
            return this.spaces[colorSpace].primaries;
        },
        getTransfer: function(colorSpace) {
            if (colorSpace === $d5b85d29c0b78636$export$bfcb490c2dd3db51) return $d5b85d29c0b78636$export$f197347d588c1b4a;
            return this.spaces[colorSpace].transfer;
        },
        getLuminanceCoefficients: function(target, colorSpace = this.workingColorSpace) {
            return target.fromArray(this.spaces[colorSpace].luminanceCoefficients);
        },
        define: function(colorSpaces) {
            Object.assign(this.spaces, colorSpaces);
        },
        // Internal APIs
        _getMatrix: function(targetMatrix, sourceColorSpace, targetColorSpace) {
            return targetMatrix.copy(this.spaces[sourceColorSpace].toXYZ).multiply(this.spaces[targetColorSpace].fromXYZ);
        },
        _getDrawingBufferColorSpace: function(colorSpace) {
            return this.spaces[colorSpace].outputColorSpaceConfig.drawingBufferColorSpace;
        },
        _getUnpackColorSpace: function(colorSpace = this.workingColorSpace) {
            return this.spaces[colorSpace].workingColorSpaceConfig.unpackColorSpace;
        }
    };
    /******************************************************************************
	 * sRGB definitions
	 */ const REC709_PRIMARIES = [
        0.640,
        0.330,
        0.300,
        0.600,
        0.150,
        0.060
    ];
    const REC709_LUMINANCE_COEFFICIENTS = [
        0.2126,
        0.7152,
        0.0722
    ];
    const D65 = [
        0.3127,
        0.3290
    ];
    ColorManagement.define({
        [$d5b85d29c0b78636$export$42429b3acfb233a4]: {
            primaries: REC709_PRIMARIES,
            whitePoint: D65,
            transfer: $d5b85d29c0b78636$export$f197347d588c1b4a,
            toXYZ: $d5b85d29c0b78636$var$LINEAR_REC709_TO_XYZ,
            fromXYZ: $d5b85d29c0b78636$var$XYZ_TO_LINEAR_REC709,
            luminanceCoefficients: REC709_LUMINANCE_COEFFICIENTS,
            workingColorSpaceConfig: {
                unpackColorSpace: $d5b85d29c0b78636$export$561f394b24edfcaa
            },
            outputColorSpaceConfig: {
                drawingBufferColorSpace: $d5b85d29c0b78636$export$561f394b24edfcaa
            }
        },
        [$d5b85d29c0b78636$export$561f394b24edfcaa]: {
            primaries: REC709_PRIMARIES,
            whitePoint: D65,
            transfer: $d5b85d29c0b78636$export$8d0a61916cc26abb,
            toXYZ: $d5b85d29c0b78636$var$LINEAR_REC709_TO_XYZ,
            fromXYZ: $d5b85d29c0b78636$var$XYZ_TO_LINEAR_REC709,
            luminanceCoefficients: REC709_LUMINANCE_COEFFICIENTS,
            outputColorSpaceConfig: {
                drawingBufferColorSpace: $d5b85d29c0b78636$export$561f394b24edfcaa
            }
        }
    });
    return ColorManagement;
}
const $d5b85d29c0b78636$export$5e6fd513f44698c = /*@__PURE__*/ $d5b85d29c0b78636$var$createColorManagement();
function $d5b85d29c0b78636$var$SRGBToLinear(c) {
    return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
}
function $d5b85d29c0b78636$var$LinearToSRGB(c) {
    return c < 0.0031308 ? c * 12.92 : 1.055 * Math.pow(c, 0.41666) - 0.055;
}
let $d5b85d29c0b78636$var$_canvas;
class $d5b85d29c0b78636$export$698882cf06df44aa {
    static getDataURL(image) {
        if (/^data:/i.test(image.src)) return image.src;
        if (typeof HTMLCanvasElement === 'undefined') return image.src;
        let canvas;
        if (image instanceof HTMLCanvasElement) canvas = image;
        else {
            if ($d5b85d29c0b78636$var$_canvas === undefined) $d5b85d29c0b78636$var$_canvas = $d5b85d29c0b78636$export$7094a064528c7fee('canvas');
            $d5b85d29c0b78636$var$_canvas.width = image.width;
            $d5b85d29c0b78636$var$_canvas.height = image.height;
            const context = $d5b85d29c0b78636$var$_canvas.getContext('2d');
            if (image instanceof ImageData) context.putImageData(image, 0, 0);
            else context.drawImage(image, 0, 0, image.width, image.height);
            canvas = $d5b85d29c0b78636$var$_canvas;
        }
        if (canvas.width > 2048 || canvas.height > 2048) {
            console.warn('THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image);
            return canvas.toDataURL('image/jpeg', 0.6);
        } else return canvas.toDataURL('image/png');
    }
    static sRGBToLinear(image) {
        if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
            const canvas = $d5b85d29c0b78636$export$7094a064528c7fee('canvas');
            canvas.width = image.width;
            canvas.height = image.height;
            const context = canvas.getContext('2d');
            context.drawImage(image, 0, 0, image.width, image.height);
            const imageData = context.getImageData(0, 0, image.width, image.height);
            const data = imageData.data;
            for(let i = 0; i < data.length; i++)data[i] = $d5b85d29c0b78636$var$SRGBToLinear(data[i] / 255) * 255;
            context.putImageData(imageData, 0, 0);
            return canvas;
        } else if (image.data) {
            const data = image.data.slice(0);
            for(let i = 0; i < data.length; i++)if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) data[i] = Math.floor($d5b85d29c0b78636$var$SRGBToLinear(data[i] / 255) * 255);
            else // assuming float
            data[i] = $d5b85d29c0b78636$var$SRGBToLinear(data[i]);
            return {
                data: data,
                width: image.width,
                height: image.height
            };
        } else {
            console.warn('THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.');
            return image;
        }
    }
}
let $d5b85d29c0b78636$var$_sourceId = 0;
class $d5b85d29c0b78636$export$1d2df86270c81ecb {
    constructor(data = null){
        this.isSource = true;
        Object.defineProperty(this, 'id', {
            value: $d5b85d29c0b78636$var$_sourceId++
        });
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.data = data;
        this.dataReady = true;
        this.version = 0;
    }
    set needsUpdate(value) {
        if (value === true) this.version++;
    }
    toJSON(meta) {
        const isRootObject = meta === undefined || typeof meta === 'string';
        if (!isRootObject && meta.images[this.uuid] !== undefined) return meta.images[this.uuid];
        const output = {
            uuid: this.uuid,
            url: ''
        };
        const data = this.data;
        if (data !== null) {
            let url;
            if (Array.isArray(data)) {
                // cube texture
                url = [];
                for(let i = 0, l = data.length; i < l; i++)if (data[i].isDataTexture) url.push($d5b85d29c0b78636$var$serializeImage(data[i].image));
                else url.push($d5b85d29c0b78636$var$serializeImage(data[i]));
            } else // texture
            url = $d5b85d29c0b78636$var$serializeImage(data);
            output.url = url;
        }
        if (!isRootObject) meta.images[this.uuid] = output;
        return output;
    }
}
function $d5b85d29c0b78636$var$serializeImage(image) {
    if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) // default images
    return $d5b85d29c0b78636$export$698882cf06df44aa.getDataURL(image);
    else {
        if (image.data) // images of DataTexture
        return {
            data: Array.from(image.data),
            width: image.width,
            height: image.height,
            type: image.data.constructor.name
        };
        else {
            console.warn('THREE.Texture: Unable to serialize Texture.');
            return {};
        }
    }
}
let $d5b85d29c0b78636$var$_textureId = 0;
class $d5b85d29c0b78636$export$5431306cf43de24a extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(image = $d5b85d29c0b78636$export$5431306cf43de24a.DEFAULT_IMAGE, mapping = $d5b85d29c0b78636$export$5431306cf43de24a.DEFAULT_MAPPING, wrapS = $d5b85d29c0b78636$export$9d9334239a5a5e06, wrapT = $d5b85d29c0b78636$export$9d9334239a5a5e06, magFilter = $d5b85d29c0b78636$export$8a72f490b25c56c8, minFilter = $d5b85d29c0b78636$export$5d8599b6a933fb1b, format = $d5b85d29c0b78636$export$3f8bb04b555a363c, type = $d5b85d29c0b78636$export$2e8ce08d3f6f5e10, anisotropy = $d5b85d29c0b78636$export$5431306cf43de24a.DEFAULT_ANISOTROPY, colorSpace = $d5b85d29c0b78636$export$bfcb490c2dd3db51){
        super();
        this.isTexture = true;
        Object.defineProperty(this, 'id', {
            value: $d5b85d29c0b78636$var$_textureId++
        });
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.name = '';
        this.source = new $d5b85d29c0b78636$export$1d2df86270c81ecb(image);
        this.mipmaps = [];
        this.mapping = mapping;
        this.channel = 0;
        this.wrapS = wrapS;
        this.wrapT = wrapT;
        this.magFilter = magFilter;
        this.minFilter = minFilter;
        this.anisotropy = anisotropy;
        this.format = format;
        this.internalFormat = null;
        this.type = type;
        this.offset = new $d5b85d29c0b78636$export$c977b3e384af9ae1(0, 0);
        this.repeat = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.center = new $d5b85d29c0b78636$export$c977b3e384af9ae1(0, 0);
        this.rotation = 0;
        this.matrixAutoUpdate = true;
        this.matrix = new $d5b85d29c0b78636$export$8ff26dafa08918();
        this.generateMipmaps = true;
        this.premultiplyAlpha = false;
        this.flipY = true;
        this.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
        this.colorSpace = colorSpace;
        this.userData = {};
        this.version = 0;
        this.onUpdate = null;
        this.renderTarget = null; // assign texture to a render target
        this.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not
        this.pmremVersion = 0; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)
    }
    get image() {
        return this.source.data;
    }
    set image(value = null) {
        this.source.data = value;
    }
    updateMatrix() {
        this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y);
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(source) {
        this.name = source.name;
        this.source = source.source;
        this.mipmaps = source.mipmaps.slice(0);
        this.mapping = source.mapping;
        this.channel = source.channel;
        this.wrapS = source.wrapS;
        this.wrapT = source.wrapT;
        this.magFilter = source.magFilter;
        this.minFilter = source.minFilter;
        this.anisotropy = source.anisotropy;
        this.format = source.format;
        this.internalFormat = source.internalFormat;
        this.type = source.type;
        this.offset.copy(source.offset);
        this.repeat.copy(source.repeat);
        this.center.copy(source.center);
        this.rotation = source.rotation;
        this.matrixAutoUpdate = source.matrixAutoUpdate;
        this.matrix.copy(source.matrix);
        this.generateMipmaps = source.generateMipmaps;
        this.premultiplyAlpha = source.premultiplyAlpha;
        this.flipY = source.flipY;
        this.unpackAlignment = source.unpackAlignment;
        this.colorSpace = source.colorSpace;
        this.renderTarget = source.renderTarget;
        this.isRenderTargetTexture = source.isRenderTargetTexture;
        this.userData = JSON.parse(JSON.stringify(source.userData));
        this.needsUpdate = true;
        return this;
    }
    toJSON(meta) {
        const isRootObject = meta === undefined || typeof meta === 'string';
        if (!isRootObject && meta.textures[this.uuid] !== undefined) return meta.textures[this.uuid];
        const output = {
            metadata: {
                version: 4.6,
                type: 'Texture',
                generator: 'Texture.toJSON'
            },
            uuid: this.uuid,
            name: this.name,
            image: this.source.toJSON(meta).uuid,
            mapping: this.mapping,
            channel: this.channel,
            repeat: [
                this.repeat.x,
                this.repeat.y
            ],
            offset: [
                this.offset.x,
                this.offset.y
            ],
            center: [
                this.center.x,
                this.center.y
            ],
            rotation: this.rotation,
            wrap: [
                this.wrapS,
                this.wrapT
            ],
            format: this.format,
            internalFormat: this.internalFormat,
            type: this.type,
            colorSpace: this.colorSpace,
            minFilter: this.minFilter,
            magFilter: this.magFilter,
            anisotropy: this.anisotropy,
            flipY: this.flipY,
            generateMipmaps: this.generateMipmaps,
            premultiplyAlpha: this.premultiplyAlpha,
            unpackAlignment: this.unpackAlignment
        };
        if (Object.keys(this.userData).length > 0) output.userData = this.userData;
        if (!isRootObject) meta.textures[this.uuid] = output;
        return output;
    }
    dispose() {
        this.dispatchEvent({
            type: 'dispose'
        });
    }
    transformUv(uv) {
        if (this.mapping !== $d5b85d29c0b78636$export$1beec6768cbb3d2d) return uv;
        uv.applyMatrix3(this.matrix);
        if (uv.x < 0 || uv.x > 1) switch(this.wrapS){
            case $d5b85d29c0b78636$export$533346c8e8dac0f5:
                uv.x = uv.x - Math.floor(uv.x);
                break;
            case $d5b85d29c0b78636$export$9d9334239a5a5e06:
                uv.x = uv.x < 0 ? 0 : 1;
                break;
            case $d5b85d29c0b78636$export$c7e7c00b14f51a4f:
                if (Math.abs(Math.floor(uv.x) % 2) === 1) uv.x = Math.ceil(uv.x) - uv.x;
                else uv.x = uv.x - Math.floor(uv.x);
                break;
        }
        if (uv.y < 0 || uv.y > 1) switch(this.wrapT){
            case $d5b85d29c0b78636$export$533346c8e8dac0f5:
                uv.y = uv.y - Math.floor(uv.y);
                break;
            case $d5b85d29c0b78636$export$9d9334239a5a5e06:
                uv.y = uv.y < 0 ? 0 : 1;
                break;
            case $d5b85d29c0b78636$export$c7e7c00b14f51a4f:
                if (Math.abs(Math.floor(uv.y) % 2) === 1) uv.y = Math.ceil(uv.y) - uv.y;
                else uv.y = uv.y - Math.floor(uv.y);
                break;
        }
        if (this.flipY) uv.y = 1 - uv.y;
        return uv;
    }
    set needsUpdate(value) {
        if (value === true) {
            this.version++;
            this.source.needsUpdate = true;
        }
    }
    set needsPMREMUpdate(value) {
        if (value === true) this.pmremVersion++;
    }
}
$d5b85d29c0b78636$export$5431306cf43de24a.DEFAULT_IMAGE = null;
$d5b85d29c0b78636$export$5431306cf43de24a.DEFAULT_MAPPING = $d5b85d29c0b78636$export$1beec6768cbb3d2d;
$d5b85d29c0b78636$export$5431306cf43de24a.DEFAULT_ANISOTROPY = 1;
class $d5b85d29c0b78636$export$fa7daccca11cdbe3 {
    constructor(x = 0, y = 0, z = 0, w = 1){
        $d5b85d29c0b78636$export$fa7daccca11cdbe3.prototype.isVector4 = true;
        this.x = x;
        this.y = y;
        this.z = z;
        this.w = w;
    }
    get width() {
        return this.z;
    }
    set width(value) {
        this.z = value;
    }
    get height() {
        return this.w;
    }
    set height(value) {
        this.w = value;
    }
    set(x, y, z, w) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.w = w;
        return this;
    }
    setScalar(scalar) {
        this.x = scalar;
        this.y = scalar;
        this.z = scalar;
        this.w = scalar;
        return this;
    }
    setX(x) {
        this.x = x;
        return this;
    }
    setY(y) {
        this.y = y;
        return this;
    }
    setZ(z) {
        this.z = z;
        return this;
    }
    setW(w) {
        this.w = w;
        return this;
    }
    setComponent(index, value) {
        switch(index){
            case 0:
                this.x = value;
                break;
            case 1:
                this.y = value;
                break;
            case 2:
                this.z = value;
                break;
            case 3:
                this.w = value;
                break;
            default:
                throw new Error('index is out of range: ' + index);
        }
        return this;
    }
    getComponent(index) {
        switch(index){
            case 0:
                return this.x;
            case 1:
                return this.y;
            case 2:
                return this.z;
            case 3:
                return this.w;
            default:
                throw new Error('index is out of range: ' + index);
        }
    }
    clone() {
        return new this.constructor(this.x, this.y, this.z, this.w);
    }
    copy(v) {
        this.x = v.x;
        this.y = v.y;
        this.z = v.z;
        this.w = v.w !== undefined ? v.w : 1;
        return this;
    }
    add(v) {
        this.x += v.x;
        this.y += v.y;
        this.z += v.z;
        this.w += v.w;
        return this;
    }
    addScalar(s) {
        this.x += s;
        this.y += s;
        this.z += s;
        this.w += s;
        return this;
    }
    addVectors(a, b) {
        this.x = a.x + b.x;
        this.y = a.y + b.y;
        this.z = a.z + b.z;
        this.w = a.w + b.w;
        return this;
    }
    addScaledVector(v, s) {
        this.x += v.x * s;
        this.y += v.y * s;
        this.z += v.z * s;
        this.w += v.w * s;
        return this;
    }
    sub(v) {
        this.x -= v.x;
        this.y -= v.y;
        this.z -= v.z;
        this.w -= v.w;
        return this;
    }
    subScalar(s) {
        this.x -= s;
        this.y -= s;
        this.z -= s;
        this.w -= s;
        return this;
    }
    subVectors(a, b) {
        this.x = a.x - b.x;
        this.y = a.y - b.y;
        this.z = a.z - b.z;
        this.w = a.w - b.w;
        return this;
    }
    multiply(v) {
        this.x *= v.x;
        this.y *= v.y;
        this.z *= v.z;
        this.w *= v.w;
        return this;
    }
    multiplyScalar(scalar) {
        this.x *= scalar;
        this.y *= scalar;
        this.z *= scalar;
        this.w *= scalar;
        return this;
    }
    applyMatrix4(m) {
        const x = this.x, y = this.y, z = this.z, w = this.w;
        const e = m.elements;
        this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w;
        this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w;
        this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w;
        this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w;
        return this;
    }
    divide(v) {
        this.x /= v.x;
        this.y /= v.y;
        this.z /= v.z;
        this.w /= v.w;
        return this;
    }
    divideScalar(scalar) {
        return this.multiplyScalar(1 / scalar);
    }
    setAxisAngleFromQuaternion(q) {
        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
        // q is assumed to be normalized
        this.w = 2 * Math.acos(q.w);
        const s = Math.sqrt(1 - q.w * q.w);
        if (s < 0.0001) {
            this.x = 1;
            this.y = 0;
            this.z = 0;
        } else {
            this.x = q.x / s;
            this.y = q.y / s;
            this.z = q.z / s;
        }
        return this;
    }
    setAxisAngleFromRotationMatrix(m) {
        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
        let angle, x, y, z; // variables for result
        const epsilon = 0.01, epsilon2 = 0.1, te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10];
        if (Math.abs(m12 - m21) < epsilon && Math.abs(m13 - m31) < epsilon && Math.abs(m23 - m32) < epsilon) {
            // singularity found
            // first check for identity matrix which must have +1 for all terms
            // in leading diagonal and zero in other terms
            if (Math.abs(m12 + m21) < epsilon2 && Math.abs(m13 + m31) < epsilon2 && Math.abs(m23 + m32) < epsilon2 && Math.abs(m11 + m22 + m33 - 3) < epsilon2) {
                // this singularity is identity matrix so angle = 0
                this.set(1, 0, 0, 0);
                return this; // zero angle, arbitrary axis
            }
            // otherwise this singularity is angle = 180
            angle = Math.PI;
            const xx = (m11 + 1) / 2;
            const yy = (m22 + 1) / 2;
            const zz = (m33 + 1) / 2;
            const xy = (m12 + m21) / 4;
            const xz = (m13 + m31) / 4;
            const yz = (m23 + m32) / 4;
            if (xx > yy && xx > zz) {
                // m11 is the largest diagonal term
                if (xx < epsilon) {
                    x = 0;
                    y = 0.707106781;
                    z = 0.707106781;
                } else {
                    x = Math.sqrt(xx);
                    y = xy / x;
                    z = xz / x;
                }
            } else if (yy > zz) {
                // m22 is the largest diagonal term
                if (yy < epsilon) {
                    x = 0.707106781;
                    y = 0;
                    z = 0.707106781;
                } else {
                    y = Math.sqrt(yy);
                    x = xy / y;
                    z = yz / y;
                }
            } else // m33 is the largest diagonal term so base result on this
            if (zz < epsilon) {
                x = 0.707106781;
                y = 0.707106781;
                z = 0;
            } else {
                z = Math.sqrt(zz);
                x = xz / z;
                y = yz / z;
            }
            this.set(x, y, z, angle);
            return this; // return 180 deg rotation
        }
        // as we have reached here there are no singularities so we can handle normally
        let s = Math.sqrt((m32 - m23) * (m32 - m23) + (m13 - m31) * (m13 - m31) + (m21 - m12) * (m21 - m12)); // used to normalize
        if (Math.abs(s) < 0.001) s = 1;
        // prevent divide by zero, should not happen if matrix is orthogonal and should be
        // caught by singularity test above, but I've left it in just in case
        this.x = (m32 - m23) / s;
        this.y = (m13 - m31) / s;
        this.z = (m21 - m12) / s;
        this.w = Math.acos((m11 + m22 + m33 - 1) / 2);
        return this;
    }
    setFromMatrixPosition(m) {
        const e = m.elements;
        this.x = e[12];
        this.y = e[13];
        this.z = e[14];
        this.w = e[15];
        return this;
    }
    min(v) {
        this.x = Math.min(this.x, v.x);
        this.y = Math.min(this.y, v.y);
        this.z = Math.min(this.z, v.z);
        this.w = Math.min(this.w, v.w);
        return this;
    }
    max(v) {
        this.x = Math.max(this.x, v.x);
        this.y = Math.max(this.y, v.y);
        this.z = Math.max(this.z, v.z);
        this.w = Math.max(this.w, v.w);
        return this;
    }
    clamp(min, max) {
        // assumes min < max, componentwise
        this.x = $d5b85d29c0b78636$var$clamp(this.x, min.x, max.x);
        this.y = $d5b85d29c0b78636$var$clamp(this.y, min.y, max.y);
        this.z = $d5b85d29c0b78636$var$clamp(this.z, min.z, max.z);
        this.w = $d5b85d29c0b78636$var$clamp(this.w, min.w, max.w);
        return this;
    }
    clampScalar(minVal, maxVal) {
        this.x = $d5b85d29c0b78636$var$clamp(this.x, minVal, maxVal);
        this.y = $d5b85d29c0b78636$var$clamp(this.y, minVal, maxVal);
        this.z = $d5b85d29c0b78636$var$clamp(this.z, minVal, maxVal);
        this.w = $d5b85d29c0b78636$var$clamp(this.w, minVal, maxVal);
        return this;
    }
    clampLength(min, max) {
        const length = this.length();
        return this.divideScalar(length || 1).multiplyScalar($d5b85d29c0b78636$var$clamp(length, min, max));
    }
    floor() {
        this.x = Math.floor(this.x);
        this.y = Math.floor(this.y);
        this.z = Math.floor(this.z);
        this.w = Math.floor(this.w);
        return this;
    }
    ceil() {
        this.x = Math.ceil(this.x);
        this.y = Math.ceil(this.y);
        this.z = Math.ceil(this.z);
        this.w = Math.ceil(this.w);
        return this;
    }
    round() {
        this.x = Math.round(this.x);
        this.y = Math.round(this.y);
        this.z = Math.round(this.z);
        this.w = Math.round(this.w);
        return this;
    }
    roundToZero() {
        this.x = Math.trunc(this.x);
        this.y = Math.trunc(this.y);
        this.z = Math.trunc(this.z);
        this.w = Math.trunc(this.w);
        return this;
    }
    negate() {
        this.x = -this.x;
        this.y = -this.y;
        this.z = -this.z;
        this.w = -this.w;
        return this;
    }
    dot(v) {
        return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
    }
    lengthSq() {
        return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
    }
    length() {
        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
    }
    manhattanLength() {
        return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w);
    }
    normalize() {
        return this.divideScalar(this.length() || 1);
    }
    setLength(length) {
        return this.normalize().multiplyScalar(length);
    }
    lerp(v, alpha) {
        this.x += (v.x - this.x) * alpha;
        this.y += (v.y - this.y) * alpha;
        this.z += (v.z - this.z) * alpha;
        this.w += (v.w - this.w) * alpha;
        return this;
    }
    lerpVectors(v1, v2, alpha) {
        this.x = v1.x + (v2.x - v1.x) * alpha;
        this.y = v1.y + (v2.y - v1.y) * alpha;
        this.z = v1.z + (v2.z - v1.z) * alpha;
        this.w = v1.w + (v2.w - v1.w) * alpha;
        return this;
    }
    equals(v) {
        return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w;
    }
    fromArray(array, offset = 0) {
        this.x = array[offset];
        this.y = array[offset + 1];
        this.z = array[offset + 2];
        this.w = array[offset + 3];
        return this;
    }
    toArray(array = [], offset = 0) {
        array[offset] = this.x;
        array[offset + 1] = this.y;
        array[offset + 2] = this.z;
        array[offset + 3] = this.w;
        return array;
    }
    fromBufferAttribute(attribute, index) {
        this.x = attribute.getX(index);
        this.y = attribute.getY(index);
        this.z = attribute.getZ(index);
        this.w = attribute.getW(index);
        return this;
    }
    random() {
        this.x = Math.random();
        this.y = Math.random();
        this.z = Math.random();
        this.w = Math.random();
        return this;
    }
    *[Symbol.iterator]() {
        yield this.x;
        yield this.y;
        yield this.z;
        yield this.w;
    }
}
/*
 In options, we can specify:
 * Texture parameters for an auto-generated target texture
 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
*/ class $d5b85d29c0b78636$export$efcb1f8bf367cbfb extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(width = 1, height = 1, options = {}){
        super();
        this.isRenderTarget = true;
        this.width = width;
        this.height = height;
        this.depth = 1;
        this.scissor = new $d5b85d29c0b78636$export$fa7daccca11cdbe3(0, 0, width, height);
        this.scissorTest = false;
        this.viewport = new $d5b85d29c0b78636$export$fa7daccca11cdbe3(0, 0, width, height);
        const image = {
            width: width,
            height: height,
            depth: 1
        };
        options = Object.assign({
            generateMipmaps: false,
            internalFormat: null,
            minFilter: $d5b85d29c0b78636$export$8a72f490b25c56c8,
            depthBuffer: true,
            stencilBuffer: false,
            resolveDepthBuffer: true,
            resolveStencilBuffer: true,
            depthTexture: null,
            samples: 0,
            count: 1
        }, options);
        const texture = new $d5b85d29c0b78636$export$5431306cf43de24a(image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace);
        texture.flipY = false;
        texture.generateMipmaps = options.generateMipmaps;
        texture.internalFormat = options.internalFormat;
        this.textures = [];
        const count = options.count;
        for(let i = 0; i < count; i++){
            this.textures[i] = texture.clone();
            this.textures[i].isRenderTargetTexture = true;
            this.textures[i].renderTarget = this;
        }
        this.depthBuffer = options.depthBuffer;
        this.stencilBuffer = options.stencilBuffer;
        this.resolveDepthBuffer = options.resolveDepthBuffer;
        this.resolveStencilBuffer = options.resolveStencilBuffer;
        this._depthTexture = null;
        this.depthTexture = options.depthTexture;
        this.samples = options.samples;
    }
    get texture() {
        return this.textures[0];
    }
    set texture(value) {
        this.textures[0] = value;
    }
    set depthTexture(current) {
        if (this._depthTexture !== null) this._depthTexture.renderTarget = null;
        if (current !== null) current.renderTarget = this;
        this._depthTexture = current;
    }
    get depthTexture() {
        return this._depthTexture;
    }
    setSize(width, height, depth = 1) {
        if (this.width !== width || this.height !== height || this.depth !== depth) {
            this.width = width;
            this.height = height;
            this.depth = depth;
            for(let i = 0, il = this.textures.length; i < il; i++){
                this.textures[i].image.width = width;
                this.textures[i].image.height = height;
                this.textures[i].image.depth = depth;
            }
            this.dispose();
        }
        this.viewport.set(0, 0, width, height);
        this.scissor.set(0, 0, width, height);
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(source) {
        this.width = source.width;
        this.height = source.height;
        this.depth = source.depth;
        this.scissor.copy(source.scissor);
        this.scissorTest = source.scissorTest;
        this.viewport.copy(source.viewport);
        this.textures.length = 0;
        for(let i = 0, il = source.textures.length; i < il; i++){
            this.textures[i] = source.textures[i].clone();
            this.textures[i].isRenderTargetTexture = true;
            this.textures[i].renderTarget = this;
        }
        // ensure image object is not shared, see #20328
        const image = Object.assign({}, source.texture.image);
        this.texture.source = new $d5b85d29c0b78636$export$1d2df86270c81ecb(image);
        this.depthBuffer = source.depthBuffer;
        this.stencilBuffer = source.stencilBuffer;
        this.resolveDepthBuffer = source.resolveDepthBuffer;
        this.resolveStencilBuffer = source.resolveStencilBuffer;
        if (source.depthTexture !== null) this.depthTexture = source.depthTexture.clone();
        this.samples = source.samples;
        return this;
    }
    dispose() {
        this.dispatchEvent({
            type: 'dispose'
        });
    }
}
class $d5b85d29c0b78636$export$3c052beb2e51e23f extends $d5b85d29c0b78636$export$efcb1f8bf367cbfb {
    constructor(width = 1, height = 1, options = {}){
        super(width, height, options);
        this.isWebGLRenderTarget = true;
    }
}
class $d5b85d29c0b78636$export$dfac6c8e811406a3 extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(data = null, width = 1, height = 1, depth = 1){
        super(null);
        this.isDataArrayTexture = true;
        this.image = {
            data: data,
            width: width,
            height: height,
            depth: depth
        };
        this.magFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.minFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.wrapR = $d5b85d29c0b78636$export$9d9334239a5a5e06;
        this.generateMipmaps = false;
        this.flipY = false;
        this.unpackAlignment = 1;
        this.layerUpdates = new Set();
    }
    addLayerUpdate(layerIndex) {
        this.layerUpdates.add(layerIndex);
    }
    clearLayerUpdates() {
        this.layerUpdates.clear();
    }
}
class $d5b85d29c0b78636$export$c77a02c11ed180c7 extends $d5b85d29c0b78636$export$3c052beb2e51e23f {
    constructor(width = 1, height = 1, depth = 1, options = {}){
        super(width, height, options);
        this.isWebGLArrayRenderTarget = true;
        this.depth = depth;
        this.texture = new $d5b85d29c0b78636$export$dfac6c8e811406a3(null, width, height, depth);
        this.texture.isRenderTargetTexture = true;
    }
}
class $d5b85d29c0b78636$export$d7a3086320f856db extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(data = null, width = 1, height = 1, depth = 1){
        // We're going to add .setXXX() methods for setting properties later.
        // Users can still set in Data3DTexture directly.
        //
        //	const texture = new THREE.Data3DTexture( data, width, height, depth );
        // 	texture.anisotropy = 16;
        //
        // See #14839
        super(null);
        this.isData3DTexture = true;
        this.image = {
            data: data,
            width: width,
            height: height,
            depth: depth
        };
        this.magFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.minFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.wrapR = $d5b85d29c0b78636$export$9d9334239a5a5e06;
        this.generateMipmaps = false;
        this.flipY = false;
        this.unpackAlignment = 1;
    }
}
class $d5b85d29c0b78636$export$7ee06591009639df extends $d5b85d29c0b78636$export$3c052beb2e51e23f {
    constructor(width = 1, height = 1, depth = 1, options = {}){
        super(width, height, options);
        this.isWebGL3DRenderTarget = true;
        this.depth = depth;
        this.texture = new $d5b85d29c0b78636$export$d7a3086320f856db(null, width, height, depth);
        this.texture.isRenderTargetTexture = true;
    }
}
class $d5b85d29c0b78636$export$23d6a54f0bbc85a3 {
    constructor(x = 0, y = 0, z = 0, w = 1){
        this.isQuaternion = true;
        this._x = x;
        this._y = y;
        this._z = z;
        this._w = w;
    }
    static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
        // fuzz-free, array-based Quaternion SLERP operation
        let x0 = src0[srcOffset0 + 0], y0 = src0[srcOffset0 + 1], z0 = src0[srcOffset0 + 2], w0 = src0[srcOffset0 + 3];
        const x1 = src1[srcOffset1 + 0], y1 = src1[srcOffset1 + 1], z1 = src1[srcOffset1 + 2], w1 = src1[srcOffset1 + 3];
        if (t === 0) {
            dst[dstOffset + 0] = x0;
            dst[dstOffset + 1] = y0;
            dst[dstOffset + 2] = z0;
            dst[dstOffset + 3] = w0;
            return;
        }
        if (t === 1) {
            dst[dstOffset + 0] = x1;
            dst[dstOffset + 1] = y1;
            dst[dstOffset + 2] = z1;
            dst[dstOffset + 3] = w1;
            return;
        }
        if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
            let s = 1 - t;
            const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, dir = cos >= 0 ? 1 : -1, sqrSin = 1 - cos * cos;
            // Skip the Slerp for tiny steps to avoid numeric problems:
            if (sqrSin > Number.EPSILON) {
                const sin = Math.sqrt(sqrSin), len = Math.atan2(sin, cos * dir);
                s = Math.sin(s * len) / sin;
                t = Math.sin(t * len) / sin;
            }
            const tDir = t * dir;
            x0 = x0 * s + x1 * tDir;
            y0 = y0 * s + y1 * tDir;
            z0 = z0 * s + z1 * tDir;
            w0 = w0 * s + w1 * tDir;
            // Normalize in case we just did a lerp:
            if (s === 1 - t) {
                const f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
                x0 *= f;
                y0 *= f;
                z0 *= f;
                w0 *= f;
            }
        }
        dst[dstOffset] = x0;
        dst[dstOffset + 1] = y0;
        dst[dstOffset + 2] = z0;
        dst[dstOffset + 3] = w0;
    }
    static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
        const x0 = src0[srcOffset0];
        const y0 = src0[srcOffset0 + 1];
        const z0 = src0[srcOffset0 + 2];
        const w0 = src0[srcOffset0 + 3];
        const x1 = src1[srcOffset1];
        const y1 = src1[srcOffset1 + 1];
        const z1 = src1[srcOffset1 + 2];
        const w1 = src1[srcOffset1 + 3];
        dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
        dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
        dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
        dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
        return dst;
    }
    get x() {
        return this._x;
    }
    set x(value) {
        this._x = value;
        this._onChangeCallback();
    }
    get y() {
        return this._y;
    }
    set y(value) {
        this._y = value;
        this._onChangeCallback();
    }
    get z() {
        return this._z;
    }
    set z(value) {
        this._z = value;
        this._onChangeCallback();
    }
    get w() {
        return this._w;
    }
    set w(value) {
        this._w = value;
        this._onChangeCallback();
    }
    set(x, y, z, w) {
        this._x = x;
        this._y = y;
        this._z = z;
        this._w = w;
        this._onChangeCallback();
        return this;
    }
    clone() {
        return new this.constructor(this._x, this._y, this._z, this._w);
    }
    copy(quaternion) {
        this._x = quaternion.x;
        this._y = quaternion.y;
        this._z = quaternion.z;
        this._w = quaternion.w;
        this._onChangeCallback();
        return this;
    }
    setFromEuler(euler, update = true) {
        const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
        // http://www.mathworks.com/matlabcentral/fileexchange/
        // 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
        //	content/SpinCalc.m
        const cos = Math.cos;
        const sin = Math.sin;
        const c1 = cos(x / 2);
        const c2 = cos(y / 2);
        const c3 = cos(z / 2);
        const s1 = sin(x / 2);
        const s2 = sin(y / 2);
        const s3 = sin(z / 2);
        switch(order){
            case 'XYZ':
                this._x = s1 * c2 * c3 + c1 * s2 * s3;
                this._y = c1 * s2 * c3 - s1 * c2 * s3;
                this._z = c1 * c2 * s3 + s1 * s2 * c3;
                this._w = c1 * c2 * c3 - s1 * s2 * s3;
                break;
            case 'YXZ':
                this._x = s1 * c2 * c3 + c1 * s2 * s3;
                this._y = c1 * s2 * c3 - s1 * c2 * s3;
                this._z = c1 * c2 * s3 - s1 * s2 * c3;
                this._w = c1 * c2 * c3 + s1 * s2 * s3;
                break;
            case 'ZXY':
                this._x = s1 * c2 * c3 - c1 * s2 * s3;
                this._y = c1 * s2 * c3 + s1 * c2 * s3;
                this._z = c1 * c2 * s3 + s1 * s2 * c3;
                this._w = c1 * c2 * c3 - s1 * s2 * s3;
                break;
            case 'ZYX':
                this._x = s1 * c2 * c3 - c1 * s2 * s3;
                this._y = c1 * s2 * c3 + s1 * c2 * s3;
                this._z = c1 * c2 * s3 - s1 * s2 * c3;
                this._w = c1 * c2 * c3 + s1 * s2 * s3;
                break;
            case 'YZX':
                this._x = s1 * c2 * c3 + c1 * s2 * s3;
                this._y = c1 * s2 * c3 + s1 * c2 * s3;
                this._z = c1 * c2 * s3 - s1 * s2 * c3;
                this._w = c1 * c2 * c3 - s1 * s2 * s3;
                break;
            case 'XZY':
                this._x = s1 * c2 * c3 - c1 * s2 * s3;
                this._y = c1 * s2 * c3 - s1 * c2 * s3;
                this._z = c1 * c2 * s3 + s1 * s2 * c3;
                this._w = c1 * c2 * c3 + s1 * s2 * s3;
                break;
            default:
                console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
        }
        if (update === true) this._onChangeCallback();
        return this;
    }
    setFromAxisAngle(axis, angle) {
        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
        // assumes axis is normalized
        const halfAngle = angle / 2, s = Math.sin(halfAngle);
        this._x = axis.x * s;
        this._y = axis.y * s;
        this._z = axis.z * s;
        this._w = Math.cos(halfAngle);
        this._onChangeCallback();
        return this;
    }
    setFromRotationMatrix(m) {
        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
        const te = m.elements, m11 = te[0], m12 = te[4], m13 = te[8], m21 = te[1], m22 = te[5], m23 = te[9], m31 = te[2], m32 = te[6], m33 = te[10], trace = m11 + m22 + m33;
        if (trace > 0) {
            const s = 0.5 / Math.sqrt(trace + 1.0);
            this._w = 0.25 / s;
            this._x = (m32 - m23) * s;
            this._y = (m13 - m31) * s;
            this._z = (m21 - m12) * s;
        } else if (m11 > m22 && m11 > m33) {
            const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
            this._w = (m32 - m23) / s;
            this._x = 0.25 * s;
            this._y = (m12 + m21) / s;
            this._z = (m13 + m31) / s;
        } else if (m22 > m33) {
            const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
            this._w = (m13 - m31) / s;
            this._x = (m12 + m21) / s;
            this._y = 0.25 * s;
            this._z = (m23 + m32) / s;
        } else {
            const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
            this._w = (m21 - m12) / s;
            this._x = (m13 + m31) / s;
            this._y = (m23 + m32) / s;
            this._z = 0.25 * s;
        }
        this._onChangeCallback();
        return this;
    }
    setFromUnitVectors(vFrom, vTo) {
        // assumes direction vectors vFrom and vTo are normalized
        let r = vFrom.dot(vTo) + 1;
        if (r < Number.EPSILON) {
            // vFrom and vTo point in opposite directions
            r = 0;
            if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
                this._x = -vFrom.y;
                this._y = vFrom.x;
                this._z = 0;
                this._w = r;
            } else {
                this._x = 0;
                this._y = -vFrom.z;
                this._z = vFrom.y;
                this._w = r;
            }
        } else {
            // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
            this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
            this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
            this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
            this._w = r;
        }
        return this.normalize();
    }
    angleTo(q) {
        return 2 * Math.acos(Math.abs($d5b85d29c0b78636$var$clamp(this.dot(q), -1, 1)));
    }
    rotateTowards(q, step) {
        const angle = this.angleTo(q);
        if (angle === 0) return this;
        const t = Math.min(1, step / angle);
        this.slerp(q, t);
        return this;
    }
    identity() {
        return this.set(0, 0, 0, 1);
    }
    invert() {
        // quaternion is assumed to have unit length
        return this.conjugate();
    }
    conjugate() {
        this._x *= -1;
        this._y *= -1;
        this._z *= -1;
        this._onChangeCallback();
        return this;
    }
    dot(v) {
        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
    }
    lengthSq() {
        return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
    }
    length() {
        return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
    }
    normalize() {
        let l = this.length();
        if (l === 0) {
            this._x = 0;
            this._y = 0;
            this._z = 0;
            this._w = 1;
        } else {
            l = 1 / l;
            this._x = this._x * l;
            this._y = this._y * l;
            this._z = this._z * l;
            this._w = this._w * l;
        }
        this._onChangeCallback();
        return this;
    }
    multiply(q) {
        return this.multiplyQuaternions(this, q);
    }
    premultiply(q) {
        return this.multiplyQuaternions(q, this);
    }
    multiplyQuaternions(a, b) {
        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
        const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
        const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
        this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
        this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
        this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
        this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
        this._onChangeCallback();
        return this;
    }
    slerp(qb, t) {
        if (t === 0) return this;
        if (t === 1) return this.copy(qb);
        const x = this._x, y = this._y, z = this._z, w = this._w;
        // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
        let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
        if (cosHalfTheta < 0) {
            this._w = -qb._w;
            this._x = -qb._x;
            this._y = -qb._y;
            this._z = -qb._z;
            cosHalfTheta = -cosHalfTheta;
        } else this.copy(qb);
        if (cosHalfTheta >= 1.0) {
            this._w = w;
            this._x = x;
            this._y = y;
            this._z = z;
            return this;
        }
        const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
        if (sqrSinHalfTheta <= Number.EPSILON) {
            const s = 1 - t;
            this._w = s * w + t * this._w;
            this._x = s * x + t * this._x;
            this._y = s * y + t * this._y;
            this._z = s * z + t * this._z;
            this.normalize(); // normalize calls _onChangeCallback()
            return this;
        }
        const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
        const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
        const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta, ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
        this._w = w * ratioA + this._w * ratioB;
        this._x = x * ratioA + this._x * ratioB;
        this._y = y * ratioA + this._y * ratioB;
        this._z = z * ratioA + this._z * ratioB;
        this._onChangeCallback();
        return this;
    }
    slerpQuaternions(qa, qb, t) {
        return this.copy(qa).slerp(qb, t);
    }
    random() {
        // sets this quaternion to a uniform random unit quaternnion
        // Ken Shoemake
        // Uniform random rotations
        // D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.
        const theta1 = 2 * Math.PI * Math.random();
        const theta2 = 2 * Math.PI * Math.random();
        const x0 = Math.random();
        const r1 = Math.sqrt(1 - x0);
        const r2 = Math.sqrt(x0);
        return this.set(r1 * Math.sin(theta1), r1 * Math.cos(theta1), r2 * Math.sin(theta2), r2 * Math.cos(theta2));
    }
    equals(quaternion) {
        return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
    }
    fromArray(array, offset = 0) {
        this._x = array[offset];
        this._y = array[offset + 1];
        this._z = array[offset + 2];
        this._w = array[offset + 3];
        this._onChangeCallback();
        return this;
    }
    toArray(array = [], offset = 0) {
        array[offset] = this._x;
        array[offset + 1] = this._y;
        array[offset + 2] = this._z;
        array[offset + 3] = this._w;
        return array;
    }
    fromBufferAttribute(attribute, index) {
        this._x = attribute.getX(index);
        this._y = attribute.getY(index);
        this._z = attribute.getZ(index);
        this._w = attribute.getW(index);
        this._onChangeCallback();
        return this;
    }
    toJSON() {
        return this.toArray();
    }
    _onChange(callback) {
        this._onChangeCallback = callback;
        return this;
    }
    _onChangeCallback() {}
    *[Symbol.iterator]() {
        yield this._x;
        yield this._y;
        yield this._z;
        yield this._w;
    }
}
class $d5b85d29c0b78636$export$64b5c384219d3699 {
    constructor(x = 0, y = 0, z = 0){
        $d5b85d29c0b78636$export$64b5c384219d3699.prototype.isVector3 = true;
        this.x = x;
        this.y = y;
        this.z = z;
    }
    set(x, y, z) {
        if (z === undefined) z = this.z; // sprite.scale.set(x,y)
        this.x = x;
        this.y = y;
        this.z = z;
        return this;
    }
    setScalar(scalar) {
        this.x = scalar;
        this.y = scalar;
        this.z = scalar;
        return this;
    }
    setX(x) {
        this.x = x;
        return this;
    }
    setY(y) {
        this.y = y;
        return this;
    }
    setZ(z) {
        this.z = z;
        return this;
    }
    setComponent(index, value) {
        switch(index){
            case 0:
                this.x = value;
                break;
            case 1:
                this.y = value;
                break;
            case 2:
                this.z = value;
                break;
            default:
                throw new Error('index is out of range: ' + index);
        }
        return this;
    }
    getComponent(index) {
        switch(index){
            case 0:
                return this.x;
            case 1:
                return this.y;
            case 2:
                return this.z;
            default:
                throw new Error('index is out of range: ' + index);
        }
    }
    clone() {
        return new this.constructor(this.x, this.y, this.z);
    }
    copy(v) {
        this.x = v.x;
        this.y = v.y;
        this.z = v.z;
        return this;
    }
    add(v) {
        this.x += v.x;
        this.y += v.y;
        this.z += v.z;
        return this;
    }
    addScalar(s) {
        this.x += s;
        this.y += s;
        this.z += s;
        return this;
    }
    addVectors(a, b) {
        this.x = a.x + b.x;
        this.y = a.y + b.y;
        this.z = a.z + b.z;
        return this;
    }
    addScaledVector(v, s) {
        this.x += v.x * s;
        this.y += v.y * s;
        this.z += v.z * s;
        return this;
    }
    sub(v) {
        this.x -= v.x;
        this.y -= v.y;
        this.z -= v.z;
        return this;
    }
    subScalar(s) {
        this.x -= s;
        this.y -= s;
        this.z -= s;
        return this;
    }
    subVectors(a, b) {
        this.x = a.x - b.x;
        this.y = a.y - b.y;
        this.z = a.z - b.z;
        return this;
    }
    multiply(v) {
        this.x *= v.x;
        this.y *= v.y;
        this.z *= v.z;
        return this;
    }
    multiplyScalar(scalar) {
        this.x *= scalar;
        this.y *= scalar;
        this.z *= scalar;
        return this;
    }
    multiplyVectors(a, b) {
        this.x = a.x * b.x;
        this.y = a.y * b.y;
        this.z = a.z * b.z;
        return this;
    }
    applyEuler(euler) {
        return this.applyQuaternion($d5b85d29c0b78636$var$_quaternion$4.setFromEuler(euler));
    }
    applyAxisAngle(axis, angle) {
        return this.applyQuaternion($d5b85d29c0b78636$var$_quaternion$4.setFromAxisAngle(axis, angle));
    }
    applyMatrix3(m) {
        const x = this.x, y = this.y, z = this.z;
        const e = m.elements;
        this.x = e[0] * x + e[3] * y + e[6] * z;
        this.y = e[1] * x + e[4] * y + e[7] * z;
        this.z = e[2] * x + e[5] * y + e[8] * z;
        return this;
    }
    applyNormalMatrix(m) {
        return this.applyMatrix3(m).normalize();
    }
    applyMatrix4(m) {
        const x = this.x, y = this.y, z = this.z;
        const e = m.elements;
        const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
        this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
        this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
        this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
        return this;
    }
    applyQuaternion(q) {
        // quaternion q is assumed to have unit length
        const vx = this.x, vy = this.y, vz = this.z;
        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
        // t = 2 * cross( q.xyz, v );
        const tx = 2 * (qy * vz - qz * vy);
        const ty = 2 * (qz * vx - qx * vz);
        const tz = 2 * (qx * vy - qy * vx);
        // v + q.w * t + cross( q.xyz, t );
        this.x = vx + qw * tx + qy * tz - qz * ty;
        this.y = vy + qw * ty + qz * tx - qx * tz;
        this.z = vz + qw * tz + qx * ty - qy * tx;
        return this;
    }
    project(camera) {
        return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
    }
    unproject(camera) {
        return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
    }
    transformDirection(m) {
        // input: THREE.Matrix4 affine matrix
        // vector interpreted as a direction
        const x = this.x, y = this.y, z = this.z;
        const e = m.elements;
        this.x = e[0] * x + e[4] * y + e[8] * z;
        this.y = e[1] * x + e[5] * y + e[9] * z;
        this.z = e[2] * x + e[6] * y + e[10] * z;
        return this.normalize();
    }
    divide(v) {
        this.x /= v.x;
        this.y /= v.y;
        this.z /= v.z;
        return this;
    }
    divideScalar(scalar) {
        return this.multiplyScalar(1 / scalar);
    }
    min(v) {
        this.x = Math.min(this.x, v.x);
        this.y = Math.min(this.y, v.y);
        this.z = Math.min(this.z, v.z);
        return this;
    }
    max(v) {
        this.x = Math.max(this.x, v.x);
        this.y = Math.max(this.y, v.y);
        this.z = Math.max(this.z, v.z);
        return this;
    }
    clamp(min, max) {
        // assumes min < max, componentwise
        this.x = $d5b85d29c0b78636$var$clamp(this.x, min.x, max.x);
        this.y = $d5b85d29c0b78636$var$clamp(this.y, min.y, max.y);
        this.z = $d5b85d29c0b78636$var$clamp(this.z, min.z, max.z);
        return this;
    }
    clampScalar(minVal, maxVal) {
        this.x = $d5b85d29c0b78636$var$clamp(this.x, minVal, maxVal);
        this.y = $d5b85d29c0b78636$var$clamp(this.y, minVal, maxVal);
        this.z = $d5b85d29c0b78636$var$clamp(this.z, minVal, maxVal);
        return this;
    }
    clampLength(min, max) {
        const length = this.length();
        return this.divideScalar(length || 1).multiplyScalar($d5b85d29c0b78636$var$clamp(length, min, max));
    }
    floor() {
        this.x = Math.floor(this.x);
        this.y = Math.floor(this.y);
        this.z = Math.floor(this.z);
        return this;
    }
    ceil() {
        this.x = Math.ceil(this.x);
        this.y = Math.ceil(this.y);
        this.z = Math.ceil(this.z);
        return this;
    }
    round() {
        this.x = Math.round(this.x);
        this.y = Math.round(this.y);
        this.z = Math.round(this.z);
        return this;
    }
    roundToZero() {
        this.x = Math.trunc(this.x);
        this.y = Math.trunc(this.y);
        this.z = Math.trunc(this.z);
        return this;
    }
    negate() {
        this.x = -this.x;
        this.y = -this.y;
        this.z = -this.z;
        return this;
    }
    dot(v) {
        return this.x * v.x + this.y * v.y + this.z * v.z;
    }
    // TODO lengthSquared?
    lengthSq() {
        return this.x * this.x + this.y * this.y + this.z * this.z;
    }
    length() {
        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
    }
    manhattanLength() {
        return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
    }
    normalize() {
        return this.divideScalar(this.length() || 1);
    }
    setLength(length) {
        return this.normalize().multiplyScalar(length);
    }
    lerp(v, alpha) {
        this.x += (v.x - this.x) * alpha;
        this.y += (v.y - this.y) * alpha;
        this.z += (v.z - this.z) * alpha;
        return this;
    }
    lerpVectors(v1, v2, alpha) {
        this.x = v1.x + (v2.x - v1.x) * alpha;
        this.y = v1.y + (v2.y - v1.y) * alpha;
        this.z = v1.z + (v2.z - v1.z) * alpha;
        return this;
    }
    cross(v) {
        return this.crossVectors(this, v);
    }
    crossVectors(a, b) {
        const ax = a.x, ay = a.y, az = a.z;
        const bx = b.x, by = b.y, bz = b.z;
        this.x = ay * bz - az * by;
        this.y = az * bx - ax * bz;
        this.z = ax * by - ay * bx;
        return this;
    }
    projectOnVector(v) {
        const denominator = v.lengthSq();
        if (denominator === 0) return this.set(0, 0, 0);
        const scalar = v.dot(this) / denominator;
        return this.copy(v).multiplyScalar(scalar);
    }
    projectOnPlane(planeNormal) {
        $d5b85d29c0b78636$var$_vector$c.copy(this).projectOnVector(planeNormal);
        return this.sub($d5b85d29c0b78636$var$_vector$c);
    }
    reflect(normal) {
        // reflect incident vector off plane orthogonal to normal
        // normal is assumed to have unit length
        return this.sub($d5b85d29c0b78636$var$_vector$c.copy(normal).multiplyScalar(2 * this.dot(normal)));
    }
    angleTo(v) {
        const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
        if (denominator === 0) return Math.PI / 2;
        const theta = this.dot(v) / denominator;
        // clamp, to handle numerical problems
        return Math.acos($d5b85d29c0b78636$var$clamp(theta, -1, 1));
    }
    distanceTo(v) {
        return Math.sqrt(this.distanceToSquared(v));
    }
    distanceToSquared(v) {
        const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
        return dx * dx + dy * dy + dz * dz;
    }
    manhattanDistanceTo(v) {
        return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
    }
    setFromSpherical(s) {
        return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
    }
    setFromSphericalCoords(radius, phi, theta) {
        const sinPhiRadius = Math.sin(phi) * radius;
        this.x = sinPhiRadius * Math.sin(theta);
        this.y = Math.cos(phi) * radius;
        this.z = sinPhiRadius * Math.cos(theta);
        return this;
    }
    setFromCylindrical(c) {
        return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
    }
    setFromCylindricalCoords(radius, theta, y) {
        this.x = radius * Math.sin(theta);
        this.y = y;
        this.z = radius * Math.cos(theta);
        return this;
    }
    setFromMatrixPosition(m) {
        const e = m.elements;
        this.x = e[12];
        this.y = e[13];
        this.z = e[14];
        return this;
    }
    setFromMatrixScale(m) {
        const sx = this.setFromMatrixColumn(m, 0).length();
        const sy = this.setFromMatrixColumn(m, 1).length();
        const sz = this.setFromMatrixColumn(m, 2).length();
        this.x = sx;
        this.y = sy;
        this.z = sz;
        return this;
    }
    setFromMatrixColumn(m, index) {
        return this.fromArray(m.elements, index * 4);
    }
    setFromMatrix3Column(m, index) {
        return this.fromArray(m.elements, index * 3);
    }
    setFromEuler(e) {
        this.x = e._x;
        this.y = e._y;
        this.z = e._z;
        return this;
    }
    setFromColor(c) {
        this.x = c.r;
        this.y = c.g;
        this.z = c.b;
        return this;
    }
    equals(v) {
        return v.x === this.x && v.y === this.y && v.z === this.z;
    }
    fromArray(array, offset = 0) {
        this.x = array[offset];
        this.y = array[offset + 1];
        this.z = array[offset + 2];
        return this;
    }
    toArray(array = [], offset = 0) {
        array[offset] = this.x;
        array[offset + 1] = this.y;
        array[offset + 2] = this.z;
        return array;
    }
    fromBufferAttribute(attribute, index) {
        this.x = attribute.getX(index);
        this.y = attribute.getY(index);
        this.z = attribute.getZ(index);
        return this;
    }
    random() {
        this.x = Math.random();
        this.y = Math.random();
        this.z = Math.random();
        return this;
    }
    randomDirection() {
        // https://mathworld.wolfram.com/SpherePointPicking.html
        const theta = Math.random() * Math.PI * 2;
        const u = Math.random() * 2 - 1;
        const c = Math.sqrt(1 - u * u);
        this.x = c * Math.cos(theta);
        this.y = u;
        this.z = c * Math.sin(theta);
        return this;
    }
    *[Symbol.iterator]() {
        yield this.x;
        yield this.y;
        yield this.z;
    }
}
const $d5b85d29c0b78636$var$_vector$c = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_quaternion$4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
class $d5b85d29c0b78636$export$6f7d5a9418ab2aa3 {
    constructor(min = new $d5b85d29c0b78636$export$64b5c384219d3699(Infinity, Infinity, Infinity), max = new $d5b85d29c0b78636$export$64b5c384219d3699(-Infinity, -Infinity, -Infinity)){
        this.isBox3 = true;
        this.min = min;
        this.max = max;
    }
    set(min, max) {
        this.min.copy(min);
        this.max.copy(max);
        return this;
    }
    setFromArray(array) {
        this.makeEmpty();
        for(let i = 0, il = array.length; i < il; i += 3)this.expandByPoint($d5b85d29c0b78636$var$_vector$b.fromArray(array, i));
        return this;
    }
    setFromBufferAttribute(attribute) {
        this.makeEmpty();
        for(let i = 0, il = attribute.count; i < il; i++)this.expandByPoint($d5b85d29c0b78636$var$_vector$b.fromBufferAttribute(attribute, i));
        return this;
    }
    setFromPoints(points) {
        this.makeEmpty();
        for(let i = 0, il = points.length; i < il; i++)this.expandByPoint(points[i]);
        return this;
    }
    setFromCenterAndSize(center, size) {
        const halfSize = $d5b85d29c0b78636$var$_vector$b.copy(size).multiplyScalar(0.5);
        this.min.copy(center).sub(halfSize);
        this.max.copy(center).add(halfSize);
        return this;
    }
    setFromObject(object, precise = false) {
        this.makeEmpty();
        return this.expandByObject(object, precise);
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(box) {
        this.min.copy(box.min);
        this.max.copy(box.max);
        return this;
    }
    makeEmpty() {
        this.min.x = this.min.y = this.min.z = Infinity;
        this.max.x = this.max.y = this.max.z = -Infinity;
        return this;
    }
    isEmpty() {
        // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
        return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z;
    }
    getCenter(target) {
        return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5);
    }
    getSize(target) {
        return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min);
    }
    expandByPoint(point) {
        this.min.min(point);
        this.max.max(point);
        return this;
    }
    expandByVector(vector) {
        this.min.sub(vector);
        this.max.add(vector);
        return this;
    }
    expandByScalar(scalar) {
        this.min.addScalar(-scalar);
        this.max.addScalar(scalar);
        return this;
    }
    expandByObject(object, precise = false) {
        // Computes the world-axis-aligned bounding box of an object (including its children),
        // accounting for both the object's, and children's, world transforms
        object.updateWorldMatrix(false, false);
        const geometry = object.geometry;
        if (geometry !== undefined) {
            const positionAttribute = geometry.getAttribute('position');
            // precise AABB computation based on vertex data requires at least a position attribute.
            // instancing isn't supported so far and uses the normal (conservative) code path.
            if (precise === true && positionAttribute !== undefined && object.isInstancedMesh !== true) for(let i = 0, l = positionAttribute.count; i < l; i++){
                if (object.isMesh === true) object.getVertexPosition(i, $d5b85d29c0b78636$var$_vector$b);
                else $d5b85d29c0b78636$var$_vector$b.fromBufferAttribute(positionAttribute, i);
                $d5b85d29c0b78636$var$_vector$b.applyMatrix4(object.matrixWorld);
                this.expandByPoint($d5b85d29c0b78636$var$_vector$b);
            }
            else {
                if (object.boundingBox !== undefined) {
                    // object-level bounding box
                    if (object.boundingBox === null) object.computeBoundingBox();
                    $d5b85d29c0b78636$var$_box$4.copy(object.boundingBox);
                } else {
                    // geometry-level bounding box
                    if (geometry.boundingBox === null) geometry.computeBoundingBox();
                    $d5b85d29c0b78636$var$_box$4.copy(geometry.boundingBox);
                }
                $d5b85d29c0b78636$var$_box$4.applyMatrix4(object.matrixWorld);
                this.union($d5b85d29c0b78636$var$_box$4);
            }
        }
        const children = object.children;
        for(let i = 0, l = children.length; i < l; i++)this.expandByObject(children[i], precise);
        return this;
    }
    containsPoint(point) {
        return point.x >= this.min.x && point.x <= this.max.x && point.y >= this.min.y && point.y <= this.max.y && point.z >= this.min.z && point.z <= this.max.z;
    }
    containsBox(box) {
        return this.min.x <= box.min.x && box.max.x <= this.max.x && this.min.y <= box.min.y && box.max.y <= this.max.y && this.min.z <= box.min.z && box.max.z <= this.max.z;
    }
    getParameter(point, target) {
        // This can potentially have a divide by zero if the box
        // has a size dimension of 0.
        return target.set((point.x - this.min.x) / (this.max.x - this.min.x), (point.y - this.min.y) / (this.max.y - this.min.y), (point.z - this.min.z) / (this.max.z - this.min.z));
    }
    intersectsBox(box) {
        // using 6 splitting planes to rule out intersections.
        return box.max.x >= this.min.x && box.min.x <= this.max.x && box.max.y >= this.min.y && box.min.y <= this.max.y && box.max.z >= this.min.z && box.min.z <= this.max.z;
    }
    intersectsSphere(sphere) {
        // Find the point on the AABB closest to the sphere center.
        this.clampPoint(sphere.center, $d5b85d29c0b78636$var$_vector$b);
        // If that point is inside the sphere, the AABB and sphere intersect.
        return $d5b85d29c0b78636$var$_vector$b.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius;
    }
    intersectsPlane(plane) {
        // We compute the minimum and maximum dot product values. If those values
        // are on the same side (back or front) of the plane, then there is no intersection.
        let min, max;
        if (plane.normal.x > 0) {
            min = plane.normal.x * this.min.x;
            max = plane.normal.x * this.max.x;
        } else {
            min = plane.normal.x * this.max.x;
            max = plane.normal.x * this.min.x;
        }
        if (plane.normal.y > 0) {
            min += plane.normal.y * this.min.y;
            max += plane.normal.y * this.max.y;
        } else {
            min += plane.normal.y * this.max.y;
            max += plane.normal.y * this.min.y;
        }
        if (plane.normal.z > 0) {
            min += plane.normal.z * this.min.z;
            max += plane.normal.z * this.max.z;
        } else {
            min += plane.normal.z * this.max.z;
            max += plane.normal.z * this.min.z;
        }
        return min <= -plane.constant && max >= -plane.constant;
    }
    intersectsTriangle(triangle) {
        if (this.isEmpty()) return false;
        // compute box center and extents
        this.getCenter($d5b85d29c0b78636$var$_center);
        $d5b85d29c0b78636$var$_extents.subVectors(this.max, $d5b85d29c0b78636$var$_center);
        // translate triangle to aabb origin
        $d5b85d29c0b78636$var$_v0$2.subVectors(triangle.a, $d5b85d29c0b78636$var$_center);
        $d5b85d29c0b78636$var$_v1$7.subVectors(triangle.b, $d5b85d29c0b78636$var$_center);
        $d5b85d29c0b78636$var$_v2$4.subVectors(triangle.c, $d5b85d29c0b78636$var$_center);
        // compute edge vectors for triangle
        $d5b85d29c0b78636$var$_f0.subVectors($d5b85d29c0b78636$var$_v1$7, $d5b85d29c0b78636$var$_v0$2);
        $d5b85d29c0b78636$var$_f1.subVectors($d5b85d29c0b78636$var$_v2$4, $d5b85d29c0b78636$var$_v1$7);
        $d5b85d29c0b78636$var$_f2.subVectors($d5b85d29c0b78636$var$_v0$2, $d5b85d29c0b78636$var$_v2$4);
        // test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
        // make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
        // axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
        let axes = [
            0,
            -$d5b85d29c0b78636$var$_f0.z,
            $d5b85d29c0b78636$var$_f0.y,
            0,
            -$d5b85d29c0b78636$var$_f1.z,
            $d5b85d29c0b78636$var$_f1.y,
            0,
            -$d5b85d29c0b78636$var$_f2.z,
            $d5b85d29c0b78636$var$_f2.y,
            $d5b85d29c0b78636$var$_f0.z,
            0,
            -$d5b85d29c0b78636$var$_f0.x,
            $d5b85d29c0b78636$var$_f1.z,
            0,
            -$d5b85d29c0b78636$var$_f1.x,
            $d5b85d29c0b78636$var$_f2.z,
            0,
            -$d5b85d29c0b78636$var$_f2.x,
            -$d5b85d29c0b78636$var$_f0.y,
            $d5b85d29c0b78636$var$_f0.x,
            0,
            -$d5b85d29c0b78636$var$_f1.y,
            $d5b85d29c0b78636$var$_f1.x,
            0,
            -$d5b85d29c0b78636$var$_f2.y,
            $d5b85d29c0b78636$var$_f2.x,
            0
        ];
        if (!$d5b85d29c0b78636$var$satForAxes(axes, $d5b85d29c0b78636$var$_v0$2, $d5b85d29c0b78636$var$_v1$7, $d5b85d29c0b78636$var$_v2$4, $d5b85d29c0b78636$var$_extents)) return false;
        // test 3 face normals from the aabb
        axes = [
            1,
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            1
        ];
        if (!$d5b85d29c0b78636$var$satForAxes(axes, $d5b85d29c0b78636$var$_v0$2, $d5b85d29c0b78636$var$_v1$7, $d5b85d29c0b78636$var$_v2$4, $d5b85d29c0b78636$var$_extents)) return false;
        // finally testing the face normal of the triangle
        // use already existing triangle edge vectors here
        $d5b85d29c0b78636$var$_triangleNormal.crossVectors($d5b85d29c0b78636$var$_f0, $d5b85d29c0b78636$var$_f1);
        axes = [
            $d5b85d29c0b78636$var$_triangleNormal.x,
            $d5b85d29c0b78636$var$_triangleNormal.y,
            $d5b85d29c0b78636$var$_triangleNormal.z
        ];
        return $d5b85d29c0b78636$var$satForAxes(axes, $d5b85d29c0b78636$var$_v0$2, $d5b85d29c0b78636$var$_v1$7, $d5b85d29c0b78636$var$_v2$4, $d5b85d29c0b78636$var$_extents);
    }
    clampPoint(point, target) {
        return target.copy(point).clamp(this.min, this.max);
    }
    distanceToPoint(point) {
        return this.clampPoint(point, $d5b85d29c0b78636$var$_vector$b).distanceTo(point);
    }
    getBoundingSphere(target) {
        if (this.isEmpty()) target.makeEmpty();
        else {
            this.getCenter(target.center);
            target.radius = this.getSize($d5b85d29c0b78636$var$_vector$b).length() * 0.5;
        }
        return target;
    }
    intersect(box) {
        this.min.max(box.min);
        this.max.min(box.max);
        // ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
        if (this.isEmpty()) this.makeEmpty();
        return this;
    }
    union(box) {
        this.min.min(box.min);
        this.max.max(box.max);
        return this;
    }
    applyMatrix4(matrix) {
        // transform of empty box is an empty box.
        if (this.isEmpty()) return this;
        // NOTE: I am using a binary pattern to specify all 2^3 combinations below
        $d5b85d29c0b78636$var$_points[0].set(this.min.x, this.min.y, this.min.z).applyMatrix4(matrix); // 000
        $d5b85d29c0b78636$var$_points[1].set(this.min.x, this.min.y, this.max.z).applyMatrix4(matrix); // 001
        $d5b85d29c0b78636$var$_points[2].set(this.min.x, this.max.y, this.min.z).applyMatrix4(matrix); // 010
        $d5b85d29c0b78636$var$_points[3].set(this.min.x, this.max.y, this.max.z).applyMatrix4(matrix); // 011
        $d5b85d29c0b78636$var$_points[4].set(this.max.x, this.min.y, this.min.z).applyMatrix4(matrix); // 100
        $d5b85d29c0b78636$var$_points[5].set(this.max.x, this.min.y, this.max.z).applyMatrix4(matrix); // 101
        $d5b85d29c0b78636$var$_points[6].set(this.max.x, this.max.y, this.min.z).applyMatrix4(matrix); // 110
        $d5b85d29c0b78636$var$_points[7].set(this.max.x, this.max.y, this.max.z).applyMatrix4(matrix); // 111
        this.setFromPoints($d5b85d29c0b78636$var$_points);
        return this;
    }
    translate(offset) {
        this.min.add(offset);
        this.max.add(offset);
        return this;
    }
    equals(box) {
        return box.min.equals(this.min) && box.max.equals(this.max);
    }
}
const $d5b85d29c0b78636$var$_points = [
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(),
    /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699()
];
const $d5b85d29c0b78636$var$_vector$b = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_box$4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
// triangle centered vertices
const $d5b85d29c0b78636$var$_v0$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v1$7 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v2$4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
// triangle edge vectors
const $d5b85d29c0b78636$var$_f0 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_f1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_f2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_center = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_extents = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_triangleNormal = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_testAxis = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
function $d5b85d29c0b78636$var$satForAxes(axes, v0, v1, v2, extents) {
    for(let i = 0, j = axes.length - 3; i <= j; i += 3){
        $d5b85d29c0b78636$var$_testAxis.fromArray(axes, i);
        // project the aabb onto the separating axis
        const r = extents.x * Math.abs($d5b85d29c0b78636$var$_testAxis.x) + extents.y * Math.abs($d5b85d29c0b78636$var$_testAxis.y) + extents.z * Math.abs($d5b85d29c0b78636$var$_testAxis.z);
        // project all 3 vertices of the triangle onto the separating axis
        const p0 = v0.dot($d5b85d29c0b78636$var$_testAxis);
        const p1 = v1.dot($d5b85d29c0b78636$var$_testAxis);
        const p2 = v2.dot($d5b85d29c0b78636$var$_testAxis);
        // actual test, basically see if either of the most extreme of the triangle points intersects r
        if (Math.max(-Math.max(p0, p1, p2), Math.min(p0, p1, p2)) > r) // points of the projected triangle are outside the projected half-length of the aabb
        // the axis is separating and we can exit
        return false;
    }
    return true;
}
const $d5b85d29c0b78636$var$_box$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
const $d5b85d29c0b78636$var$_v1$6 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v2$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$805e8b72413ccaba {
    constructor(center = new $d5b85d29c0b78636$export$64b5c384219d3699(), radius = -1){
        this.isSphere = true;
        this.center = center;
        this.radius = radius;
    }
    set(center, radius) {
        this.center.copy(center);
        this.radius = radius;
        return this;
    }
    setFromPoints(points, optionalCenter) {
        const center = this.center;
        if (optionalCenter !== undefined) center.copy(optionalCenter);
        else $d5b85d29c0b78636$var$_box$3.setFromPoints(points).getCenter(center);
        let maxRadiusSq = 0;
        for(let i = 0, il = points.length; i < il; i++)maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i]));
        this.radius = Math.sqrt(maxRadiusSq);
        return this;
    }
    copy(sphere) {
        this.center.copy(sphere.center);
        this.radius = sphere.radius;
        return this;
    }
    isEmpty() {
        return this.radius < 0;
    }
    makeEmpty() {
        this.center.set(0, 0, 0);
        this.radius = -1;
        return this;
    }
    containsPoint(point) {
        return point.distanceToSquared(this.center) <= this.radius * this.radius;
    }
    distanceToPoint(point) {
        return point.distanceTo(this.center) - this.radius;
    }
    intersectsSphere(sphere) {
        const radiusSum = this.radius + sphere.radius;
        return sphere.center.distanceToSquared(this.center) <= radiusSum * radiusSum;
    }
    intersectsBox(box) {
        return box.intersectsSphere(this);
    }
    intersectsPlane(plane) {
        return Math.abs(plane.distanceToPoint(this.center)) <= this.radius;
    }
    clampPoint(point, target) {
        const deltaLengthSq = this.center.distanceToSquared(point);
        target.copy(point);
        if (deltaLengthSq > this.radius * this.radius) {
            target.sub(this.center).normalize();
            target.multiplyScalar(this.radius).add(this.center);
        }
        return target;
    }
    getBoundingBox(target) {
        if (this.isEmpty()) {
            // Empty sphere produces empty bounding box
            target.makeEmpty();
            return target;
        }
        target.set(this.center, this.center);
        target.expandByScalar(this.radius);
        return target;
    }
    applyMatrix4(matrix) {
        this.center.applyMatrix4(matrix);
        this.radius = this.radius * matrix.getMaxScaleOnAxis();
        return this;
    }
    translate(offset) {
        this.center.add(offset);
        return this;
    }
    expandByPoint(point) {
        if (this.isEmpty()) {
            this.center.copy(point);
            this.radius = 0;
            return this;
        }
        $d5b85d29c0b78636$var$_v1$6.subVectors(point, this.center);
        const lengthSq = $d5b85d29c0b78636$var$_v1$6.lengthSq();
        if (lengthSq > this.radius * this.radius) {
            // calculate the minimal sphere
            const length = Math.sqrt(lengthSq);
            const delta = (length - this.radius) * 0.5;
            this.center.addScaledVector($d5b85d29c0b78636$var$_v1$6, delta / length);
            this.radius += delta;
        }
        return this;
    }
    union(sphere) {
        if (sphere.isEmpty()) return this;
        if (this.isEmpty()) {
            this.copy(sphere);
            return this;
        }
        if (this.center.equals(sphere.center) === true) this.radius = Math.max(this.radius, sphere.radius);
        else {
            $d5b85d29c0b78636$var$_v2$3.subVectors(sphere.center, this.center).setLength(sphere.radius);
            this.expandByPoint($d5b85d29c0b78636$var$_v1$6.copy(sphere.center).add($d5b85d29c0b78636$var$_v2$3));
            this.expandByPoint($d5b85d29c0b78636$var$_v1$6.copy(sphere.center).sub($d5b85d29c0b78636$var$_v2$3));
        }
        return this;
    }
    equals(sphere) {
        return sphere.center.equals(this.center) && sphere.radius === this.radius;
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
const $d5b85d29c0b78636$var$_vector$a = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_segCenter = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_segDir = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_diff = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_edge1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_edge2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_normal$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$a186db52eed6d40e {
    constructor(origin = new $d5b85d29c0b78636$export$64b5c384219d3699(), direction = new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, -1)){
        this.origin = origin;
        this.direction = direction;
    }
    set(origin, direction) {
        this.origin.copy(origin);
        this.direction.copy(direction);
        return this;
    }
    copy(ray) {
        this.origin.copy(ray.origin);
        this.direction.copy(ray.direction);
        return this;
    }
    at(t, target) {
        return target.copy(this.origin).addScaledVector(this.direction, t);
    }
    lookAt(v) {
        this.direction.copy(v).sub(this.origin).normalize();
        return this;
    }
    recast(t) {
        this.origin.copy(this.at(t, $d5b85d29c0b78636$var$_vector$a));
        return this;
    }
    closestPointToPoint(point, target) {
        target.subVectors(point, this.origin);
        const directionDistance = target.dot(this.direction);
        if (directionDistance < 0) return target.copy(this.origin);
        return target.copy(this.origin).addScaledVector(this.direction, directionDistance);
    }
    distanceToPoint(point) {
        return Math.sqrt(this.distanceSqToPoint(point));
    }
    distanceSqToPoint(point) {
        const directionDistance = $d5b85d29c0b78636$var$_vector$a.subVectors(point, this.origin).dot(this.direction);
        // point behind the ray
        if (directionDistance < 0) return this.origin.distanceToSquared(point);
        $d5b85d29c0b78636$var$_vector$a.copy(this.origin).addScaledVector(this.direction, directionDistance);
        return $d5b85d29c0b78636$var$_vector$a.distanceToSquared(point);
    }
    distanceSqToSegment(v0, v1, optionalPointOnRay, optionalPointOnSegment) {
        // from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteDistRaySegment.h
        // It returns the min distance between the ray and the segment
        // defined by v0 and v1
        // It can also set two optional targets :
        // - The closest point on the ray
        // - The closest point on the segment
        $d5b85d29c0b78636$var$_segCenter.copy(v0).add(v1).multiplyScalar(0.5);
        $d5b85d29c0b78636$var$_segDir.copy(v1).sub(v0).normalize();
        $d5b85d29c0b78636$var$_diff.copy(this.origin).sub($d5b85d29c0b78636$var$_segCenter);
        const segExtent = v0.distanceTo(v1) * 0.5;
        const a01 = -this.direction.dot($d5b85d29c0b78636$var$_segDir);
        const b0 = $d5b85d29c0b78636$var$_diff.dot(this.direction);
        const b1 = -$d5b85d29c0b78636$var$_diff.dot($d5b85d29c0b78636$var$_segDir);
        const c = $d5b85d29c0b78636$var$_diff.lengthSq();
        const det = Math.abs(1 - a01 * a01);
        let s0, s1, sqrDist, extDet;
        if (det > 0) {
            // The ray and segment are not parallel.
            s0 = a01 * b1 - b0;
            s1 = a01 * b0 - b1;
            extDet = segExtent * det;
            if (s0 >= 0) {
                if (s1 >= -extDet) {
                    if (s1 <= extDet) {
                        // region 0
                        // Minimum at interior points of ray and segment.
                        const invDet = 1 / det;
                        s0 *= invDet;
                        s1 *= invDet;
                        sqrDist = s0 * (s0 + a01 * s1 + 2 * b0) + s1 * (a01 * s0 + s1 + 2 * b1) + c;
                    } else {
                        // region 1
                        s1 = segExtent;
                        s0 = Math.max(0, -(a01 * s1 + b0));
                        sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
                    }
                } else {
                    // region 5
                    s1 = -segExtent;
                    s0 = Math.max(0, -(a01 * s1 + b0));
                    sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
                }
            } else {
                if (s1 <= -extDet) {
                    // region 4
                    s0 = Math.max(0, -(-a01 * segExtent + b0));
                    s1 = s0 > 0 ? -segExtent : Math.min(Math.max(-segExtent, -b1), segExtent);
                    sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
                } else if (s1 <= extDet) {
                    // region 3
                    s0 = 0;
                    s1 = Math.min(Math.max(-segExtent, -b1), segExtent);
                    sqrDist = s1 * (s1 + 2 * b1) + c;
                } else {
                    // region 2
                    s0 = Math.max(0, -(a01 * segExtent + b0));
                    s1 = s0 > 0 ? segExtent : Math.min(Math.max(-segExtent, -b1), segExtent);
                    sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
                }
            }
        } else {
            // Ray and segment are parallel.
            s1 = a01 > 0 ? -segExtent : segExtent;
            s0 = Math.max(0, -(a01 * s1 + b0));
            sqrDist = -s0 * s0 + s1 * (s1 + 2 * b1) + c;
        }
        if (optionalPointOnRay) optionalPointOnRay.copy(this.origin).addScaledVector(this.direction, s0);
        if (optionalPointOnSegment) optionalPointOnSegment.copy($d5b85d29c0b78636$var$_segCenter).addScaledVector($d5b85d29c0b78636$var$_segDir, s1);
        return sqrDist;
    }
    intersectSphere(sphere, target) {
        $d5b85d29c0b78636$var$_vector$a.subVectors(sphere.center, this.origin);
        const tca = $d5b85d29c0b78636$var$_vector$a.dot(this.direction);
        const d2 = $d5b85d29c0b78636$var$_vector$a.dot($d5b85d29c0b78636$var$_vector$a) - tca * tca;
        const radius2 = sphere.radius * sphere.radius;
        if (d2 > radius2) return null;
        const thc = Math.sqrt(radius2 - d2);
        // t0 = first intersect point - entrance on front of sphere
        const t0 = tca - thc;
        // t1 = second intersect point - exit point on back of sphere
        const t1 = tca + thc;
        // test to see if t1 is behind the ray - if so, return null
        if (t1 < 0) return null;
        // test to see if t0 is behind the ray:
        // if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
        // in order to always return an intersect point that is in front of the ray.
        if (t0 < 0) return this.at(t1, target);
        // else t0 is in front of the ray, so return the first collision point scaled by t0
        return this.at(t0, target);
    }
    intersectsSphere(sphere) {
        return this.distanceSqToPoint(sphere.center) <= sphere.radius * sphere.radius;
    }
    distanceToPlane(plane) {
        const denominator = plane.normal.dot(this.direction);
        if (denominator === 0) {
            // line is coplanar, return origin
            if (plane.distanceToPoint(this.origin) === 0) return 0;
            // Null is preferable to undefined since undefined means.... it is undefined
            return null;
        }
        const t = -(this.origin.dot(plane.normal) + plane.constant) / denominator;
        // Return if the ray never intersects the plane
        return t >= 0 ? t : null;
    }
    intersectPlane(plane, target) {
        const t = this.distanceToPlane(plane);
        if (t === null) return null;
        return this.at(t, target);
    }
    intersectsPlane(plane) {
        // check if the ray lies on the plane first
        const distToPoint = plane.distanceToPoint(this.origin);
        if (distToPoint === 0) return true;
        const denominator = plane.normal.dot(this.direction);
        if (denominator * distToPoint < 0) return true;
        // ray origin is behind the plane (and is pointing behind it)
        return false;
    }
    intersectBox(box, target) {
        let tmin, tmax, tymin, tymax, tzmin, tzmax;
        const invdirx = 1 / this.direction.x, invdiry = 1 / this.direction.y, invdirz = 1 / this.direction.z;
        const origin = this.origin;
        if (invdirx >= 0) {
            tmin = (box.min.x - origin.x) * invdirx;
            tmax = (box.max.x - origin.x) * invdirx;
        } else {
            tmin = (box.max.x - origin.x) * invdirx;
            tmax = (box.min.x - origin.x) * invdirx;
        }
        if (invdiry >= 0) {
            tymin = (box.min.y - origin.y) * invdiry;
            tymax = (box.max.y - origin.y) * invdiry;
        } else {
            tymin = (box.max.y - origin.y) * invdiry;
            tymax = (box.min.y - origin.y) * invdiry;
        }
        if (tmin > tymax || tymin > tmax) return null;
        if (tymin > tmin || isNaN(tmin)) tmin = tymin;
        if (tymax < tmax || isNaN(tmax)) tmax = tymax;
        if (invdirz >= 0) {
            tzmin = (box.min.z - origin.z) * invdirz;
            tzmax = (box.max.z - origin.z) * invdirz;
        } else {
            tzmin = (box.max.z - origin.z) * invdirz;
            tzmax = (box.min.z - origin.z) * invdirz;
        }
        if (tmin > tzmax || tzmin > tmax) return null;
        if (tzmin > tmin || tmin !== tmin) tmin = tzmin;
        if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
        //return point closest to the ray (positive side)
        if (tmax < 0) return null;
        return this.at(tmin >= 0 ? tmin : tmax, target);
    }
    intersectsBox(box) {
        return this.intersectBox(box, $d5b85d29c0b78636$var$_vector$a) !== null;
    }
    intersectTriangle(a, b, c, backfaceCulling, target) {
        // Compute the offset origin, edges, and normal.
        // from https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
        $d5b85d29c0b78636$var$_edge1.subVectors(b, a);
        $d5b85d29c0b78636$var$_edge2.subVectors(c, a);
        $d5b85d29c0b78636$var$_normal$1.crossVectors($d5b85d29c0b78636$var$_edge1, $d5b85d29c0b78636$var$_edge2);
        // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
        // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
        //   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
        //   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
        //   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
        let DdN = this.direction.dot($d5b85d29c0b78636$var$_normal$1);
        let sign;
        if (DdN > 0) {
            if (backfaceCulling) return null;
            sign = 1;
        } else if (DdN < 0) {
            sign = -1;
            DdN = -DdN;
        } else return null;
        $d5b85d29c0b78636$var$_diff.subVectors(this.origin, a);
        const DdQxE2 = sign * this.direction.dot($d5b85d29c0b78636$var$_edge2.crossVectors($d5b85d29c0b78636$var$_diff, $d5b85d29c0b78636$var$_edge2));
        // b1 < 0, no intersection
        if (DdQxE2 < 0) return null;
        const DdE1xQ = sign * this.direction.dot($d5b85d29c0b78636$var$_edge1.cross($d5b85d29c0b78636$var$_diff));
        // b2 < 0, no intersection
        if (DdE1xQ < 0) return null;
        // b1+b2 > 1, no intersection
        if (DdQxE2 + DdE1xQ > DdN) return null;
        // Line intersects triangle, check if ray does.
        const QdN = -sign * $d5b85d29c0b78636$var$_diff.dot($d5b85d29c0b78636$var$_normal$1);
        // t < 0, no intersection
        if (QdN < 0) return null;
        // Ray intersects triangle.
        return this.at(QdN / DdN, target);
    }
    applyMatrix4(matrix4) {
        this.origin.applyMatrix4(matrix4);
        this.direction.transformDirection(matrix4);
        return this;
    }
    equals(ray) {
        return ray.origin.equals(this.origin) && ray.direction.equals(this.direction);
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
class $d5b85d29c0b78636$export$2ae72fc923e5eb5 {
    constructor(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44){
        $d5b85d29c0b78636$export$2ae72fc923e5eb5.prototype.isMatrix4 = true;
        this.elements = [
            1,
            0,
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            0,
            1
        ];
        if (n11 !== undefined) this.set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44);
    }
    set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
        const te = this.elements;
        te[0] = n11;
        te[4] = n12;
        te[8] = n13;
        te[12] = n14;
        te[1] = n21;
        te[5] = n22;
        te[9] = n23;
        te[13] = n24;
        te[2] = n31;
        te[6] = n32;
        te[10] = n33;
        te[14] = n34;
        te[3] = n41;
        te[7] = n42;
        te[11] = n43;
        te[15] = n44;
        return this;
    }
    identity() {
        this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
        return this;
    }
    clone() {
        return new $d5b85d29c0b78636$export$2ae72fc923e5eb5().fromArray(this.elements);
    }
    copy(m) {
        const te = this.elements;
        const me = m.elements;
        te[0] = me[0];
        te[1] = me[1];
        te[2] = me[2];
        te[3] = me[3];
        te[4] = me[4];
        te[5] = me[5];
        te[6] = me[6];
        te[7] = me[7];
        te[8] = me[8];
        te[9] = me[9];
        te[10] = me[10];
        te[11] = me[11];
        te[12] = me[12];
        te[13] = me[13];
        te[14] = me[14];
        te[15] = me[15];
        return this;
    }
    copyPosition(m) {
        const te = this.elements, me = m.elements;
        te[12] = me[12];
        te[13] = me[13];
        te[14] = me[14];
        return this;
    }
    setFromMatrix3(m) {
        const me = m.elements;
        this.set(me[0], me[3], me[6], 0, me[1], me[4], me[7], 0, me[2], me[5], me[8], 0, 0, 0, 0, 1);
        return this;
    }
    extractBasis(xAxis, yAxis, zAxis) {
        xAxis.setFromMatrixColumn(this, 0);
        yAxis.setFromMatrixColumn(this, 1);
        zAxis.setFromMatrixColumn(this, 2);
        return this;
    }
    makeBasis(xAxis, yAxis, zAxis) {
        this.set(xAxis.x, yAxis.x, zAxis.x, 0, xAxis.y, yAxis.y, zAxis.y, 0, xAxis.z, yAxis.z, zAxis.z, 0, 0, 0, 0, 1);
        return this;
    }
    extractRotation(m) {
        // this method does not support reflection matrices
        const te = this.elements;
        const me = m.elements;
        const scaleX = 1 / $d5b85d29c0b78636$var$_v1$5.setFromMatrixColumn(m, 0).length();
        const scaleY = 1 / $d5b85d29c0b78636$var$_v1$5.setFromMatrixColumn(m, 1).length();
        const scaleZ = 1 / $d5b85d29c0b78636$var$_v1$5.setFromMatrixColumn(m, 2).length();
        te[0] = me[0] * scaleX;
        te[1] = me[1] * scaleX;
        te[2] = me[2] * scaleX;
        te[3] = 0;
        te[4] = me[4] * scaleY;
        te[5] = me[5] * scaleY;
        te[6] = me[6] * scaleY;
        te[7] = 0;
        te[8] = me[8] * scaleZ;
        te[9] = me[9] * scaleZ;
        te[10] = me[10] * scaleZ;
        te[11] = 0;
        te[12] = 0;
        te[13] = 0;
        te[14] = 0;
        te[15] = 1;
        return this;
    }
    makeRotationFromEuler(euler) {
        const te = this.elements;
        const x = euler.x, y = euler.y, z = euler.z;
        const a = Math.cos(x), b = Math.sin(x);
        const c = Math.cos(y), d = Math.sin(y);
        const e = Math.cos(z), f = Math.sin(z);
        if (euler.order === 'XYZ') {
            const ae = a * e, af = a * f, be = b * e, bf = b * f;
            te[0] = c * e;
            te[4] = -c * f;
            te[8] = d;
            te[1] = af + be * d;
            te[5] = ae - bf * d;
            te[9] = -b * c;
            te[2] = bf - ae * d;
            te[6] = be + af * d;
            te[10] = a * c;
        } else if (euler.order === 'YXZ') {
            const ce = c * e, cf = c * f, de = d * e, df = d * f;
            te[0] = ce + df * b;
            te[4] = de * b - cf;
            te[8] = a * d;
            te[1] = a * f;
            te[5] = a * e;
            te[9] = -b;
            te[2] = cf * b - de;
            te[6] = df + ce * b;
            te[10] = a * c;
        } else if (euler.order === 'ZXY') {
            const ce = c * e, cf = c * f, de = d * e, df = d * f;
            te[0] = ce - df * b;
            te[4] = -a * f;
            te[8] = de + cf * b;
            te[1] = cf + de * b;
            te[5] = a * e;
            te[9] = df - ce * b;
            te[2] = -a * d;
            te[6] = b;
            te[10] = a * c;
        } else if (euler.order === 'ZYX') {
            const ae = a * e, af = a * f, be = b * e, bf = b * f;
            te[0] = c * e;
            te[4] = be * d - af;
            te[8] = ae * d + bf;
            te[1] = c * f;
            te[5] = bf * d + ae;
            te[9] = af * d - be;
            te[2] = -d;
            te[6] = b * c;
            te[10] = a * c;
        } else if (euler.order === 'YZX') {
            const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
            te[0] = c * e;
            te[4] = bd - ac * f;
            te[8] = bc * f + ad;
            te[1] = f;
            te[5] = a * e;
            te[9] = -b * e;
            te[2] = -d * e;
            te[6] = ad * f + bc;
            te[10] = ac - bd * f;
        } else if (euler.order === 'XZY') {
            const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
            te[0] = c * e;
            te[4] = -f;
            te[8] = d * e;
            te[1] = ac * f + bd;
            te[5] = a * e;
            te[9] = ad * f - bc;
            te[2] = bc * f - ad;
            te[6] = b * e;
            te[10] = bd * f + ac;
        }
        // bottom row
        te[3] = 0;
        te[7] = 0;
        te[11] = 0;
        // last column
        te[12] = 0;
        te[13] = 0;
        te[14] = 0;
        te[15] = 1;
        return this;
    }
    makeRotationFromQuaternion(q) {
        return this.compose($d5b85d29c0b78636$var$_zero, q, $d5b85d29c0b78636$var$_one);
    }
    lookAt(eye, target, up) {
        const te = this.elements;
        $d5b85d29c0b78636$var$_z.subVectors(eye, target);
        if ($d5b85d29c0b78636$var$_z.lengthSq() === 0) // eye and target are in the same position
        $d5b85d29c0b78636$var$_z.z = 1;
        $d5b85d29c0b78636$var$_z.normalize();
        $d5b85d29c0b78636$var$_x.crossVectors(up, $d5b85d29c0b78636$var$_z);
        if ($d5b85d29c0b78636$var$_x.lengthSq() === 0) {
            // up and z are parallel
            if (Math.abs(up.z) === 1) $d5b85d29c0b78636$var$_z.x += 0.0001;
            else $d5b85d29c0b78636$var$_z.z += 0.0001;
            $d5b85d29c0b78636$var$_z.normalize();
            $d5b85d29c0b78636$var$_x.crossVectors(up, $d5b85d29c0b78636$var$_z);
        }
        $d5b85d29c0b78636$var$_x.normalize();
        $d5b85d29c0b78636$var$_y.crossVectors($d5b85d29c0b78636$var$_z, $d5b85d29c0b78636$var$_x);
        te[0] = $d5b85d29c0b78636$var$_x.x;
        te[4] = $d5b85d29c0b78636$var$_y.x;
        te[8] = $d5b85d29c0b78636$var$_z.x;
        te[1] = $d5b85d29c0b78636$var$_x.y;
        te[5] = $d5b85d29c0b78636$var$_y.y;
        te[9] = $d5b85d29c0b78636$var$_z.y;
        te[2] = $d5b85d29c0b78636$var$_x.z;
        te[6] = $d5b85d29c0b78636$var$_y.z;
        te[10] = $d5b85d29c0b78636$var$_z.z;
        return this;
    }
    multiply(m) {
        return this.multiplyMatrices(this, m);
    }
    premultiply(m) {
        return this.multiplyMatrices(m, this);
    }
    multiplyMatrices(a, b) {
        const ae = a.elements;
        const be = b.elements;
        const te = this.elements;
        const a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
        const a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
        const a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
        const a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
        const b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
        const b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
        const b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
        const b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
        te[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
        te[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
        te[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
        te[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
        te[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
        te[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
        te[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
        te[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
        te[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
        te[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
        te[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
        te[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
        te[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
        te[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
        te[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
        te[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
        return this;
    }
    multiplyScalar(s) {
        const te = this.elements;
        te[0] *= s;
        te[4] *= s;
        te[8] *= s;
        te[12] *= s;
        te[1] *= s;
        te[5] *= s;
        te[9] *= s;
        te[13] *= s;
        te[2] *= s;
        te[6] *= s;
        te[10] *= s;
        te[14] *= s;
        te[3] *= s;
        te[7] *= s;
        te[11] *= s;
        te[15] *= s;
        return this;
    }
    determinant() {
        const te = this.elements;
        const n11 = te[0], n12 = te[4], n13 = te[8], n14 = te[12];
        const n21 = te[1], n22 = te[5], n23 = te[9], n24 = te[13];
        const n31 = te[2], n32 = te[6], n33 = te[10], n34 = te[14];
        const n41 = te[3], n42 = te[7], n43 = te[11], n44 = te[15];
        //TODO: make this more efficient
        //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )
        return n41 * (+n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34) + n42 * (+n11 * n23 * n34 - n11 * n24 * n33 + n14 * n21 * n33 - n13 * n21 * n34 + n13 * n24 * n31 - n14 * n23 * n31) + n43 * (+n11 * n24 * n32 - n11 * n22 * n34 - n14 * n21 * n32 + n12 * n21 * n34 + n14 * n22 * n31 - n12 * n24 * n31) + n44 * (-n13 * n22 * n31 - n11 * n23 * n32 + n11 * n22 * n33 + n13 * n21 * n32 - n12 * n21 * n33 + n12 * n23 * n31);
    }
    transpose() {
        const te = this.elements;
        let tmp;
        tmp = te[1];
        te[1] = te[4];
        te[4] = tmp;
        tmp = te[2];
        te[2] = te[8];
        te[8] = tmp;
        tmp = te[6];
        te[6] = te[9];
        te[9] = tmp;
        tmp = te[3];
        te[3] = te[12];
        te[12] = tmp;
        tmp = te[7];
        te[7] = te[13];
        te[13] = tmp;
        tmp = te[11];
        te[11] = te[14];
        te[14] = tmp;
        return this;
    }
    setPosition(x, y, z) {
        const te = this.elements;
        if (x.isVector3) {
            te[12] = x.x;
            te[13] = x.y;
            te[14] = x.z;
        } else {
            te[12] = x;
            te[13] = y;
            te[14] = z;
        }
        return this;
    }
    invert() {
        // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
        const te = this.elements, n11 = te[0], n21 = te[1], n31 = te[2], n41 = te[3], n12 = te[4], n22 = te[5], n32 = te[6], n42 = te[7], n13 = te[8], n23 = te[9], n33 = te[10], n43 = te[11], n14 = te[12], n24 = te[13], n34 = te[14], n44 = te[15], t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44, t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44, t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44, t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
        const det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
        if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
        const detInv = 1 / det;
        te[0] = t11 * detInv;
        te[1] = (n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44) * detInv;
        te[2] = (n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44) * detInv;
        te[3] = (n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43) * detInv;
        te[4] = t12 * detInv;
        te[5] = (n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44) * detInv;
        te[6] = (n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44) * detInv;
        te[7] = (n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43) * detInv;
        te[8] = t13 * detInv;
        te[9] = (n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44) * detInv;
        te[10] = (n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44) * detInv;
        te[11] = (n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43) * detInv;
        te[12] = t14 * detInv;
        te[13] = (n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34) * detInv;
        te[14] = (n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34) * detInv;
        te[15] = (n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33) * detInv;
        return this;
    }
    scale(v) {
        const te = this.elements;
        const x = v.x, y = v.y, z = v.z;
        te[0] *= x;
        te[4] *= y;
        te[8] *= z;
        te[1] *= x;
        te[5] *= y;
        te[9] *= z;
        te[2] *= x;
        te[6] *= y;
        te[10] *= z;
        te[3] *= x;
        te[7] *= y;
        te[11] *= z;
        return this;
    }
    getMaxScaleOnAxis() {
        const te = this.elements;
        const scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2];
        const scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6];
        const scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10];
        return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq));
    }
    makeTranslation(x, y, z) {
        if (x.isVector3) this.set(1, 0, 0, x.x, 0, 1, 0, x.y, 0, 0, 1, x.z, 0, 0, 0, 1);
        else this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1);
        return this;
    }
    makeRotationX(theta) {
        const c = Math.cos(theta), s = Math.sin(theta);
        this.set(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
        return this;
    }
    makeRotationY(theta) {
        const c = Math.cos(theta), s = Math.sin(theta);
        this.set(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);
        return this;
    }
    makeRotationZ(theta) {
        const c = Math.cos(theta), s = Math.sin(theta);
        this.set(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
        return this;
    }
    makeRotationAxis(axis, angle) {
        // Based on http://www.gamedev.net/reference/articles/article1199.asp
        const c = Math.cos(angle);
        const s = Math.sin(angle);
        const t = 1 - c;
        const x = axis.x, y = axis.y, z = axis.z;
        const tx = t * x, ty = t * y;
        this.set(tx * x + c, tx * y - s * z, tx * z + s * y, 0, tx * y + s * z, ty * y + c, ty * z - s * x, 0, tx * z - s * y, ty * z + s * x, t * z * z + c, 0, 0, 0, 0, 1);
        return this;
    }
    makeScale(x, y, z) {
        this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);
        return this;
    }
    makeShear(xy, xz, yx, yz, zx, zy) {
        this.set(1, yx, zx, 0, xy, 1, zy, 0, xz, yz, 1, 0, 0, 0, 0, 1);
        return this;
    }
    compose(position, quaternion, scale) {
        const te = this.elements;
        const x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
        const x2 = x + x, y2 = y + y, z2 = z + z;
        const xx = x * x2, xy = x * y2, xz = x * z2;
        const yy = y * y2, yz = y * z2, zz = z * z2;
        const wx = w * x2, wy = w * y2, wz = w * z2;
        const sx = scale.x, sy = scale.y, sz = scale.z;
        te[0] = (1 - (yy + zz)) * sx;
        te[1] = (xy + wz) * sx;
        te[2] = (xz - wy) * sx;
        te[3] = 0;
        te[4] = (xy - wz) * sy;
        te[5] = (1 - (xx + zz)) * sy;
        te[6] = (yz + wx) * sy;
        te[7] = 0;
        te[8] = (xz + wy) * sz;
        te[9] = (yz - wx) * sz;
        te[10] = (1 - (xx + yy)) * sz;
        te[11] = 0;
        te[12] = position.x;
        te[13] = position.y;
        te[14] = position.z;
        te[15] = 1;
        return this;
    }
    decompose(position, quaternion, scale) {
        const te = this.elements;
        let sx = $d5b85d29c0b78636$var$_v1$5.set(te[0], te[1], te[2]).length();
        const sy = $d5b85d29c0b78636$var$_v1$5.set(te[4], te[5], te[6]).length();
        const sz = $d5b85d29c0b78636$var$_v1$5.set(te[8], te[9], te[10]).length();
        // if determine is negative, we need to invert one scale
        const det = this.determinant();
        if (det < 0) sx = -sx;
        position.x = te[12];
        position.y = te[13];
        position.z = te[14];
        // scale the rotation part
        $d5b85d29c0b78636$var$_m1$2.copy(this);
        const invSX = 1 / sx;
        const invSY = 1 / sy;
        const invSZ = 1 / sz;
        $d5b85d29c0b78636$var$_m1$2.elements[0] *= invSX;
        $d5b85d29c0b78636$var$_m1$2.elements[1] *= invSX;
        $d5b85d29c0b78636$var$_m1$2.elements[2] *= invSX;
        $d5b85d29c0b78636$var$_m1$2.elements[4] *= invSY;
        $d5b85d29c0b78636$var$_m1$2.elements[5] *= invSY;
        $d5b85d29c0b78636$var$_m1$2.elements[6] *= invSY;
        $d5b85d29c0b78636$var$_m1$2.elements[8] *= invSZ;
        $d5b85d29c0b78636$var$_m1$2.elements[9] *= invSZ;
        $d5b85d29c0b78636$var$_m1$2.elements[10] *= invSZ;
        quaternion.setFromRotationMatrix($d5b85d29c0b78636$var$_m1$2);
        scale.x = sx;
        scale.y = sy;
        scale.z = sz;
        return this;
    }
    makePerspective(left, right, top, bottom, near, far, coordinateSystem = $d5b85d29c0b78636$export$5a0e9190d10875d3) {
        const te = this.elements;
        const x = 2 * near / (right - left);
        const y = 2 * near / (top - bottom);
        const a = (right + left) / (right - left);
        const b = (top + bottom) / (top - bottom);
        let c, d;
        if (coordinateSystem === $d5b85d29c0b78636$export$5a0e9190d10875d3) {
            c = -(far + near) / (far - near);
            d = -2 * far * near / (far - near);
        } else if (coordinateSystem === $d5b85d29c0b78636$export$cc83beedcb9be9ac) {
            c = -far / (far - near);
            d = -far * near / (far - near);
        } else throw new Error('THREE.Matrix4.makePerspective(): Invalid coordinate system: ' + coordinateSystem);
        te[0] = x;
        te[4] = 0;
        te[8] = a;
        te[12] = 0;
        te[1] = 0;
        te[5] = y;
        te[9] = b;
        te[13] = 0;
        te[2] = 0;
        te[6] = 0;
        te[10] = c;
        te[14] = d;
        te[3] = 0;
        te[7] = 0;
        te[11] = -1;
        te[15] = 0;
        return this;
    }
    makeOrthographic(left, right, top, bottom, near, far, coordinateSystem = $d5b85d29c0b78636$export$5a0e9190d10875d3) {
        const te = this.elements;
        const w = 1.0 / (right - left);
        const h = 1.0 / (top - bottom);
        const p = 1.0 / (far - near);
        const x = (right + left) * w;
        const y = (top + bottom) * h;
        let z, zInv;
        if (coordinateSystem === $d5b85d29c0b78636$export$5a0e9190d10875d3) {
            z = (far + near) * p;
            zInv = -2 * p;
        } else if (coordinateSystem === $d5b85d29c0b78636$export$cc83beedcb9be9ac) {
            z = near * p;
            zInv = -1 * p;
        } else throw new Error('THREE.Matrix4.makeOrthographic(): Invalid coordinate system: ' + coordinateSystem);
        te[0] = 2 * w;
        te[4] = 0;
        te[8] = 0;
        te[12] = -x;
        te[1] = 0;
        te[5] = 2 * h;
        te[9] = 0;
        te[13] = -y;
        te[2] = 0;
        te[6] = 0;
        te[10] = zInv;
        te[14] = -z;
        te[3] = 0;
        te[7] = 0;
        te[11] = 0;
        te[15] = 1;
        return this;
    }
    equals(matrix) {
        const te = this.elements;
        const me = matrix.elements;
        for(let i = 0; i < 16; i++){
            if (te[i] !== me[i]) return false;
        }
        return true;
    }
    fromArray(array, offset = 0) {
        for(let i = 0; i < 16; i++)this.elements[i] = array[i + offset];
        return this;
    }
    toArray(array = [], offset = 0) {
        const te = this.elements;
        array[offset] = te[0];
        array[offset + 1] = te[1];
        array[offset + 2] = te[2];
        array[offset + 3] = te[3];
        array[offset + 4] = te[4];
        array[offset + 5] = te[5];
        array[offset + 6] = te[6];
        array[offset + 7] = te[7];
        array[offset + 8] = te[8];
        array[offset + 9] = te[9];
        array[offset + 10] = te[10];
        array[offset + 11] = te[11];
        array[offset + 12] = te[12];
        array[offset + 13] = te[13];
        array[offset + 14] = te[14];
        array[offset + 15] = te[15];
        return array;
    }
}
const $d5b85d29c0b78636$var$_v1$5 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_m1$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_zero = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, 0);
const $d5b85d29c0b78636$var$_one = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(1, 1, 1);
const $d5b85d29c0b78636$var$_x = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_y = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_z = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_matrix$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_quaternion$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
class $d5b85d29c0b78636$export$d93cc409a0768c5f {
    constructor(x = 0, y = 0, z = 0, order = $d5b85d29c0b78636$export$d93cc409a0768c5f.DEFAULT_ORDER){
        this.isEuler = true;
        this._x = x;
        this._y = y;
        this._z = z;
        this._order = order;
    }
    get x() {
        return this._x;
    }
    set x(value) {
        this._x = value;
        this._onChangeCallback();
    }
    get y() {
        return this._y;
    }
    set y(value) {
        this._y = value;
        this._onChangeCallback();
    }
    get z() {
        return this._z;
    }
    set z(value) {
        this._z = value;
        this._onChangeCallback();
    }
    get order() {
        return this._order;
    }
    set order(value) {
        this._order = value;
        this._onChangeCallback();
    }
    set(x, y, z, order = this._order) {
        this._x = x;
        this._y = y;
        this._z = z;
        this._order = order;
        this._onChangeCallback();
        return this;
    }
    clone() {
        return new this.constructor(this._x, this._y, this._z, this._order);
    }
    copy(euler) {
        this._x = euler._x;
        this._y = euler._y;
        this._z = euler._z;
        this._order = euler._order;
        this._onChangeCallback();
        return this;
    }
    setFromRotationMatrix(m, order = this._order, update = true) {
        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
        const te = m.elements;
        const m11 = te[0], m12 = te[4], m13 = te[8];
        const m21 = te[1], m22 = te[5], m23 = te[9];
        const m31 = te[2], m32 = te[6], m33 = te[10];
        switch(order){
            case 'XYZ':
                this._y = Math.asin($d5b85d29c0b78636$var$clamp(m13, -1, 1));
                if (Math.abs(m13) < 0.9999999) {
                    this._x = Math.atan2(-m23, m33);
                    this._z = Math.atan2(-m12, m11);
                } else {
                    this._x = Math.atan2(m32, m22);
                    this._z = 0;
                }
                break;
            case 'YXZ':
                this._x = Math.asin(-$d5b85d29c0b78636$var$clamp(m23, -1, 1));
                if (Math.abs(m23) < 0.9999999) {
                    this._y = Math.atan2(m13, m33);
                    this._z = Math.atan2(m21, m22);
                } else {
                    this._y = Math.atan2(-m31, m11);
                    this._z = 0;
                }
                break;
            case 'ZXY':
                this._x = Math.asin($d5b85d29c0b78636$var$clamp(m32, -1, 1));
                if (Math.abs(m32) < 0.9999999) {
                    this._y = Math.atan2(-m31, m33);
                    this._z = Math.atan2(-m12, m22);
                } else {
                    this._y = 0;
                    this._z = Math.atan2(m21, m11);
                }
                break;
            case 'ZYX':
                this._y = Math.asin(-$d5b85d29c0b78636$var$clamp(m31, -1, 1));
                if (Math.abs(m31) < 0.9999999) {
                    this._x = Math.atan2(m32, m33);
                    this._z = Math.atan2(m21, m11);
                } else {
                    this._x = 0;
                    this._z = Math.atan2(-m12, m22);
                }
                break;
            case 'YZX':
                this._z = Math.asin($d5b85d29c0b78636$var$clamp(m21, -1, 1));
                if (Math.abs(m21) < 0.9999999) {
                    this._x = Math.atan2(-m23, m22);
                    this._y = Math.atan2(-m31, m11);
                } else {
                    this._x = 0;
                    this._y = Math.atan2(m13, m33);
                }
                break;
            case 'XZY':
                this._z = Math.asin(-$d5b85d29c0b78636$var$clamp(m12, -1, 1));
                if (Math.abs(m12) < 0.9999999) {
                    this._x = Math.atan2(m32, m22);
                    this._y = Math.atan2(m13, m11);
                } else {
                    this._x = Math.atan2(-m23, m33);
                    this._y = 0;
                }
                break;
            default:
                console.warn('THREE.Euler: .setFromRotationMatrix() encountered an unknown order: ' + order);
        }
        this._order = order;
        if (update === true) this._onChangeCallback();
        return this;
    }
    setFromQuaternion(q, order, update) {
        $d5b85d29c0b78636$var$_matrix$2.makeRotationFromQuaternion(q);
        return this.setFromRotationMatrix($d5b85d29c0b78636$var$_matrix$2, order, update);
    }
    setFromVector3(v, order = this._order) {
        return this.set(v.x, v.y, v.z, order);
    }
    reorder(newOrder) {
        // WARNING: this discards revolution information -bhouston
        $d5b85d29c0b78636$var$_quaternion$3.setFromEuler(this);
        return this.setFromQuaternion($d5b85d29c0b78636$var$_quaternion$3, newOrder);
    }
    equals(euler) {
        return euler._x === this._x && euler._y === this._y && euler._z === this._z && euler._order === this._order;
    }
    fromArray(array) {
        this._x = array[0];
        this._y = array[1];
        this._z = array[2];
        if (array[3] !== undefined) this._order = array[3];
        this._onChangeCallback();
        return this;
    }
    toArray(array = [], offset = 0) {
        array[offset] = this._x;
        array[offset + 1] = this._y;
        array[offset + 2] = this._z;
        array[offset + 3] = this._order;
        return array;
    }
    _onChange(callback) {
        this._onChangeCallback = callback;
        return this;
    }
    _onChangeCallback() {}
    *[Symbol.iterator]() {
        yield this._x;
        yield this._y;
        yield this._z;
        yield this._order;
    }
}
$d5b85d29c0b78636$export$d93cc409a0768c5f.DEFAULT_ORDER = 'XYZ';
class $d5b85d29c0b78636$export$89312ce47c0ca777 {
    constructor(){
        this.mask = 1;
    }
    set(channel) {
        this.mask = (1 << channel | 0) >>> 0;
    }
    enable(channel) {
        this.mask |= 1 << channel | 0;
    }
    enableAll() {
        this.mask = -1;
    }
    toggle(channel) {
        this.mask ^= 1 << channel | 0;
    }
    disable(channel) {
        this.mask &= ~(1 << channel | 0);
    }
    disableAll() {
        this.mask = 0;
    }
    test(layers) {
        return (this.mask & layers.mask) !== 0;
    }
    isEnabled(channel) {
        return (this.mask & (1 << channel | 0)) !== 0;
    }
}
let $d5b85d29c0b78636$var$_object3DId = 0;
const $d5b85d29c0b78636$var$_v1$4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_q1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
const $d5b85d29c0b78636$var$_m1$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_target = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_position$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_scale$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_quaternion$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
const $d5b85d29c0b78636$var$_xAxis = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(1, 0, 0);
const $d5b85d29c0b78636$var$_yAxis = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0);
const $d5b85d29c0b78636$var$_zAxis = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, 1);
const $d5b85d29c0b78636$var$_addedEvent = {
    type: 'added'
};
const $d5b85d29c0b78636$var$_removedEvent = {
    type: 'removed'
};
const $d5b85d29c0b78636$var$_childaddedEvent = {
    type: 'childadded',
    child: null
};
const $d5b85d29c0b78636$var$_childremovedEvent = {
    type: 'childremoved',
    child: null
};
class $d5b85d29c0b78636$export$e4dd07dff30cc924 extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(){
        super();
        this.isObject3D = true;
        Object.defineProperty(this, 'id', {
            value: $d5b85d29c0b78636$var$_object3DId++
        });
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.name = '';
        this.type = 'Object3D';
        this.parent = null;
        this.children = [];
        this.up = $d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_UP.clone();
        const position = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const rotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        const quaternion = new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
        const scale = new $d5b85d29c0b78636$export$64b5c384219d3699(1, 1, 1);
        function onRotationChange() {
            quaternion.setFromEuler(rotation, false);
        }
        function onQuaternionChange() {
            rotation.setFromQuaternion(quaternion, undefined, false);
        }
        rotation._onChange(onRotationChange);
        quaternion._onChange(onQuaternionChange);
        Object.defineProperties(this, {
            position: {
                configurable: true,
                enumerable: true,
                value: position
            },
            rotation: {
                configurable: true,
                enumerable: true,
                value: rotation
            },
            quaternion: {
                configurable: true,
                enumerable: true,
                value: quaternion
            },
            scale: {
                configurable: true,
                enumerable: true,
                value: scale
            },
            modelViewMatrix: {
                value: new $d5b85d29c0b78636$export$2ae72fc923e5eb5()
            },
            normalMatrix: {
                value: new $d5b85d29c0b78636$export$8ff26dafa08918()
            }
        });
        this.matrix = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.matrixWorld = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.matrixAutoUpdate = $d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_MATRIX_AUTO_UPDATE;
        this.matrixWorldAutoUpdate = $d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_MATRIX_WORLD_AUTO_UPDATE; // checked by the renderer
        this.matrixWorldNeedsUpdate = false;
        this.layers = new $d5b85d29c0b78636$export$89312ce47c0ca777();
        this.visible = true;
        this.castShadow = false;
        this.receiveShadow = false;
        this.frustumCulled = true;
        this.renderOrder = 0;
        this.animations = [];
        this.userData = {};
    }
    onBeforeShadow() {}
    onAfterShadow() {}
    onBeforeRender() {}
    onAfterRender() {}
    applyMatrix4(matrix) {
        if (this.matrixAutoUpdate) this.updateMatrix();
        this.matrix.premultiply(matrix);
        this.matrix.decompose(this.position, this.quaternion, this.scale);
    }
    applyQuaternion(q) {
        this.quaternion.premultiply(q);
        return this;
    }
    setRotationFromAxisAngle(axis, angle) {
        // assumes axis is normalized
        this.quaternion.setFromAxisAngle(axis, angle);
    }
    setRotationFromEuler(euler) {
        this.quaternion.setFromEuler(euler, true);
    }
    setRotationFromMatrix(m) {
        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
        this.quaternion.setFromRotationMatrix(m);
    }
    setRotationFromQuaternion(q) {
        // assumes q is normalized
        this.quaternion.copy(q);
    }
    rotateOnAxis(axis, angle) {
        // rotate object on axis in object space
        // axis is assumed to be normalized
        $d5b85d29c0b78636$var$_q1.setFromAxisAngle(axis, angle);
        this.quaternion.multiply($d5b85d29c0b78636$var$_q1);
        return this;
    }
    rotateOnWorldAxis(axis, angle) {
        // rotate object on axis in world space
        // axis is assumed to be normalized
        // method assumes no rotated parent
        $d5b85d29c0b78636$var$_q1.setFromAxisAngle(axis, angle);
        this.quaternion.premultiply($d5b85d29c0b78636$var$_q1);
        return this;
    }
    rotateX(angle) {
        return this.rotateOnAxis($d5b85d29c0b78636$var$_xAxis, angle);
    }
    rotateY(angle) {
        return this.rotateOnAxis($d5b85d29c0b78636$var$_yAxis, angle);
    }
    rotateZ(angle) {
        return this.rotateOnAxis($d5b85d29c0b78636$var$_zAxis, angle);
    }
    translateOnAxis(axis, distance) {
        // translate object by distance along axis in object space
        // axis is assumed to be normalized
        $d5b85d29c0b78636$var$_v1$4.copy(axis).applyQuaternion(this.quaternion);
        this.position.add($d5b85d29c0b78636$var$_v1$4.multiplyScalar(distance));
        return this;
    }
    translateX(distance) {
        return this.translateOnAxis($d5b85d29c0b78636$var$_xAxis, distance);
    }
    translateY(distance) {
        return this.translateOnAxis($d5b85d29c0b78636$var$_yAxis, distance);
    }
    translateZ(distance) {
        return this.translateOnAxis($d5b85d29c0b78636$var$_zAxis, distance);
    }
    localToWorld(vector) {
        this.updateWorldMatrix(true, false);
        return vector.applyMatrix4(this.matrixWorld);
    }
    worldToLocal(vector) {
        this.updateWorldMatrix(true, false);
        return vector.applyMatrix4($d5b85d29c0b78636$var$_m1$1.copy(this.matrixWorld).invert());
    }
    lookAt(x, y, z) {
        // This method does not support objects having non-uniformly-scaled parent(s)
        if (x.isVector3) $d5b85d29c0b78636$var$_target.copy(x);
        else $d5b85d29c0b78636$var$_target.set(x, y, z);
        const parent = this.parent;
        this.updateWorldMatrix(true, false);
        $d5b85d29c0b78636$var$_position$3.setFromMatrixPosition(this.matrixWorld);
        if (this.isCamera || this.isLight) $d5b85d29c0b78636$var$_m1$1.lookAt($d5b85d29c0b78636$var$_position$3, $d5b85d29c0b78636$var$_target, this.up);
        else $d5b85d29c0b78636$var$_m1$1.lookAt($d5b85d29c0b78636$var$_target, $d5b85d29c0b78636$var$_position$3, this.up);
        this.quaternion.setFromRotationMatrix($d5b85d29c0b78636$var$_m1$1);
        if (parent) {
            $d5b85d29c0b78636$var$_m1$1.extractRotation(parent.matrixWorld);
            $d5b85d29c0b78636$var$_q1.setFromRotationMatrix($d5b85d29c0b78636$var$_m1$1);
            this.quaternion.premultiply($d5b85d29c0b78636$var$_q1.invert());
        }
    }
    add(object) {
        if (arguments.length > 1) {
            for(let i = 0; i < arguments.length; i++)this.add(arguments[i]);
            return this;
        }
        if (object === this) {
            console.error('THREE.Object3D.add: object can\'t be added as a child of itself.', object);
            return this;
        }
        if (object && object.isObject3D) {
            object.removeFromParent();
            object.parent = this;
            this.children.push(object);
            object.dispatchEvent($d5b85d29c0b78636$var$_addedEvent);
            $d5b85d29c0b78636$var$_childaddedEvent.child = object;
            this.dispatchEvent($d5b85d29c0b78636$var$_childaddedEvent);
            $d5b85d29c0b78636$var$_childaddedEvent.child = null;
        } else console.error('THREE.Object3D.add: object not an instance of THREE.Object3D.', object);
        return this;
    }
    remove(object) {
        if (arguments.length > 1) {
            for(let i = 0; i < arguments.length; i++)this.remove(arguments[i]);
            return this;
        }
        const index = this.children.indexOf(object);
        if (index !== -1) {
            object.parent = null;
            this.children.splice(index, 1);
            object.dispatchEvent($d5b85d29c0b78636$var$_removedEvent);
            $d5b85d29c0b78636$var$_childremovedEvent.child = object;
            this.dispatchEvent($d5b85d29c0b78636$var$_childremovedEvent);
            $d5b85d29c0b78636$var$_childremovedEvent.child = null;
        }
        return this;
    }
    removeFromParent() {
        const parent = this.parent;
        if (parent !== null) parent.remove(this);
        return this;
    }
    clear() {
        return this.remove(...this.children);
    }
    attach(object) {
        // adds object as a child of this, while maintaining the object's world transform
        // Note: This method does not support scene graphs having non-uniformly-scaled nodes(s)
        this.updateWorldMatrix(true, false);
        $d5b85d29c0b78636$var$_m1$1.copy(this.matrixWorld).invert();
        if (object.parent !== null) {
            object.parent.updateWorldMatrix(true, false);
            $d5b85d29c0b78636$var$_m1$1.multiply(object.parent.matrixWorld);
        }
        object.applyMatrix4($d5b85d29c0b78636$var$_m1$1);
        object.removeFromParent();
        object.parent = this;
        this.children.push(object);
        object.updateWorldMatrix(false, true);
        object.dispatchEvent($d5b85d29c0b78636$var$_addedEvent);
        $d5b85d29c0b78636$var$_childaddedEvent.child = object;
        this.dispatchEvent($d5b85d29c0b78636$var$_childaddedEvent);
        $d5b85d29c0b78636$var$_childaddedEvent.child = null;
        return this;
    }
    getObjectById(id) {
        return this.getObjectByProperty('id', id);
    }
    getObjectByName(name) {
        return this.getObjectByProperty('name', name);
    }
    getObjectByProperty(name, value) {
        if (this[name] === value) return this;
        for(let i = 0, l = this.children.length; i < l; i++){
            const child = this.children[i];
            const object = child.getObjectByProperty(name, value);
            if (object !== undefined) return object;
        }
        return undefined;
    }
    getObjectsByProperty(name, value, result = []) {
        if (this[name] === value) result.push(this);
        const children = this.children;
        for(let i = 0, l = children.length; i < l; i++)children[i].getObjectsByProperty(name, value, result);
        return result;
    }
    getWorldPosition(target) {
        this.updateWorldMatrix(true, false);
        return target.setFromMatrixPosition(this.matrixWorld);
    }
    getWorldQuaternion(target) {
        this.updateWorldMatrix(true, false);
        this.matrixWorld.decompose($d5b85d29c0b78636$var$_position$3, target, $d5b85d29c0b78636$var$_scale$2);
        return target;
    }
    getWorldScale(target) {
        this.updateWorldMatrix(true, false);
        this.matrixWorld.decompose($d5b85d29c0b78636$var$_position$3, $d5b85d29c0b78636$var$_quaternion$2, target);
        return target;
    }
    getWorldDirection(target) {
        this.updateWorldMatrix(true, false);
        const e = this.matrixWorld.elements;
        return target.set(e[8], e[9], e[10]).normalize();
    }
    raycast() {}
    traverse(callback) {
        callback(this);
        const children = this.children;
        for(let i = 0, l = children.length; i < l; i++)children[i].traverse(callback);
    }
    traverseVisible(callback) {
        if (this.visible === false) return;
        callback(this);
        const children = this.children;
        for(let i = 0, l = children.length; i < l; i++)children[i].traverseVisible(callback);
    }
    traverseAncestors(callback) {
        const parent = this.parent;
        if (parent !== null) {
            callback(parent);
            parent.traverseAncestors(callback);
        }
    }
    updateMatrix() {
        this.matrix.compose(this.position, this.quaternion, this.scale);
        this.matrixWorldNeedsUpdate = true;
    }
    updateMatrixWorld(force) {
        if (this.matrixAutoUpdate) this.updateMatrix();
        if (this.matrixWorldNeedsUpdate || force) {
            if (this.matrixWorldAutoUpdate === true) {
                if (this.parent === null) this.matrixWorld.copy(this.matrix);
                else this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
            }
            this.matrixWorldNeedsUpdate = false;
            force = true;
        }
        // make sure descendants are updated if required
        const children = this.children;
        for(let i = 0, l = children.length; i < l; i++){
            const child = children[i];
            child.updateMatrixWorld(force);
        }
    }
    updateWorldMatrix(updateParents, updateChildren) {
        const parent = this.parent;
        if (updateParents === true && parent !== null) parent.updateWorldMatrix(true, false);
        if (this.matrixAutoUpdate) this.updateMatrix();
        if (this.matrixWorldAutoUpdate === true) {
            if (this.parent === null) this.matrixWorld.copy(this.matrix);
            else this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix);
        }
        // make sure descendants are updated
        if (updateChildren === true) {
            const children = this.children;
            for(let i = 0, l = children.length; i < l; i++){
                const child = children[i];
                child.updateWorldMatrix(false, true);
            }
        }
    }
    toJSON(meta) {
        // meta is a string when called from JSON.stringify
        const isRootObject = meta === undefined || typeof meta === 'string';
        const output = {};
        // meta is a hash used to collect geometries, materials.
        // not providing it implies that this is the root object
        // being serialized.
        if (isRootObject) {
            // initialize meta obj
            meta = {
                geometries: {},
                materials: {},
                textures: {},
                images: {},
                shapes: {},
                skeletons: {},
                animations: {},
                nodes: {}
            };
            output.metadata = {
                version: 4.6,
                type: 'Object',
                generator: 'Object3D.toJSON'
            };
        }
        // standard Object3D serialization
        const object = {};
        object.uuid = this.uuid;
        object.type = this.type;
        if (this.name !== '') object.name = this.name;
        if (this.castShadow === true) object.castShadow = true;
        if (this.receiveShadow === true) object.receiveShadow = true;
        if (this.visible === false) object.visible = false;
        if (this.frustumCulled === false) object.frustumCulled = false;
        if (this.renderOrder !== 0) object.renderOrder = this.renderOrder;
        if (Object.keys(this.userData).length > 0) object.userData = this.userData;
        object.layers = this.layers.mask;
        object.matrix = this.matrix.toArray();
        object.up = this.up.toArray();
        if (this.matrixAutoUpdate === false) object.matrixAutoUpdate = false;
        // object specific properties
        if (this.isInstancedMesh) {
            object.type = 'InstancedMesh';
            object.count = this.count;
            object.instanceMatrix = this.instanceMatrix.toJSON();
            if (this.instanceColor !== null) object.instanceColor = this.instanceColor.toJSON();
        }
        if (this.isBatchedMesh) {
            object.type = 'BatchedMesh';
            object.perObjectFrustumCulled = this.perObjectFrustumCulled;
            object.sortObjects = this.sortObjects;
            object.drawRanges = this._drawRanges;
            object.reservedRanges = this._reservedRanges;
            object.visibility = this._visibility;
            object.active = this._active;
            object.bounds = this._bounds.map((bound)=>({
                    boxInitialized: bound.boxInitialized,
                    boxMin: bound.box.min.toArray(),
                    boxMax: bound.box.max.toArray(),
                    sphereInitialized: bound.sphereInitialized,
                    sphereRadius: bound.sphere.radius,
                    sphereCenter: bound.sphere.center.toArray()
                }));
            object.maxInstanceCount = this._maxInstanceCount;
            object.maxVertexCount = this._maxVertexCount;
            object.maxIndexCount = this._maxIndexCount;
            object.geometryInitialized = this._geometryInitialized;
            object.geometryCount = this._geometryCount;
            object.matricesTexture = this._matricesTexture.toJSON(meta);
            if (this._colorsTexture !== null) object.colorsTexture = this._colorsTexture.toJSON(meta);
            if (this.boundingSphere !== null) object.boundingSphere = {
                center: object.boundingSphere.center.toArray(),
                radius: object.boundingSphere.radius
            };
            if (this.boundingBox !== null) object.boundingBox = {
                min: object.boundingBox.min.toArray(),
                max: object.boundingBox.max.toArray()
            };
        }
        //
        function serialize(library, element) {
            if (library[element.uuid] === undefined) library[element.uuid] = element.toJSON(meta);
            return element.uuid;
        }
        if (this.isScene) {
            if (this.background) {
                if (this.background.isColor) object.background = this.background.toJSON();
                else if (this.background.isTexture) object.background = this.background.toJSON(meta).uuid;
            }
            if (this.environment && this.environment.isTexture && this.environment.isRenderTargetTexture !== true) object.environment = this.environment.toJSON(meta).uuid;
        } else if (this.isMesh || this.isLine || this.isPoints) {
            object.geometry = serialize(meta.geometries, this.geometry);
            const parameters = this.geometry.parameters;
            if (parameters !== undefined && parameters.shapes !== undefined) {
                const shapes = parameters.shapes;
                if (Array.isArray(shapes)) for(let i = 0, l = shapes.length; i < l; i++){
                    const shape = shapes[i];
                    serialize(meta.shapes, shape);
                }
                else serialize(meta.shapes, shapes);
            }
        }
        if (this.isSkinnedMesh) {
            object.bindMode = this.bindMode;
            object.bindMatrix = this.bindMatrix.toArray();
            if (this.skeleton !== undefined) {
                serialize(meta.skeletons, this.skeleton);
                object.skeleton = this.skeleton.uuid;
            }
        }
        if (this.material !== undefined) {
            if (Array.isArray(this.material)) {
                const uuids = [];
                for(let i = 0, l = this.material.length; i < l; i++)uuids.push(serialize(meta.materials, this.material[i]));
                object.material = uuids;
            } else object.material = serialize(meta.materials, this.material);
        }
        //
        if (this.children.length > 0) {
            object.children = [];
            for(let i = 0; i < this.children.length; i++)object.children.push(this.children[i].toJSON(meta).object);
        }
        //
        if (this.animations.length > 0) {
            object.animations = [];
            for(let i = 0; i < this.animations.length; i++){
                const animation = this.animations[i];
                object.animations.push(serialize(meta.animations, animation));
            }
        }
        if (isRootObject) {
            const geometries = extractFromCache(meta.geometries);
            const materials = extractFromCache(meta.materials);
            const textures = extractFromCache(meta.textures);
            const images = extractFromCache(meta.images);
            const shapes = extractFromCache(meta.shapes);
            const skeletons = extractFromCache(meta.skeletons);
            const animations = extractFromCache(meta.animations);
            const nodes = extractFromCache(meta.nodes);
            if (geometries.length > 0) output.geometries = geometries;
            if (materials.length > 0) output.materials = materials;
            if (textures.length > 0) output.textures = textures;
            if (images.length > 0) output.images = images;
            if (shapes.length > 0) output.shapes = shapes;
            if (skeletons.length > 0) output.skeletons = skeletons;
            if (animations.length > 0) output.animations = animations;
            if (nodes.length > 0) output.nodes = nodes;
        }
        output.object = object;
        return output;
        // extract data from the cache hash
        // remove metadata on each item
        // and return as array
        function extractFromCache(cache) {
            const values = [];
            for(const key in cache){
                const data = cache[key];
                delete data.metadata;
                values.push(data);
            }
            return values;
        }
    }
    clone(recursive) {
        return new this.constructor().copy(this, recursive);
    }
    copy(source, recursive = true) {
        this.name = source.name;
        this.up.copy(source.up);
        this.position.copy(source.position);
        this.rotation.order = source.rotation.order;
        this.quaternion.copy(source.quaternion);
        this.scale.copy(source.scale);
        this.matrix.copy(source.matrix);
        this.matrixWorld.copy(source.matrixWorld);
        this.matrixAutoUpdate = source.matrixAutoUpdate;
        this.matrixWorldAutoUpdate = source.matrixWorldAutoUpdate;
        this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
        this.layers.mask = source.layers.mask;
        this.visible = source.visible;
        this.castShadow = source.castShadow;
        this.receiveShadow = source.receiveShadow;
        this.frustumCulled = source.frustumCulled;
        this.renderOrder = source.renderOrder;
        this.animations = source.animations.slice();
        this.userData = JSON.parse(JSON.stringify(source.userData));
        if (recursive === true) for(let i = 0; i < source.children.length; i++){
            const child = source.children[i];
            this.add(child.clone());
        }
        return this;
    }
}
$d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_UP = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0);
$d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_MATRIX_AUTO_UPDATE = true;
$d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_MATRIX_WORLD_AUTO_UPDATE = true;
const $d5b85d29c0b78636$var$_v0$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v1$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v2$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v3$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vab = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vac = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vbc = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vap = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vbp = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vcp = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v40 = /*@__PURE__*/ new $d5b85d29c0b78636$export$fa7daccca11cdbe3();
const $d5b85d29c0b78636$var$_v41 = /*@__PURE__*/ new $d5b85d29c0b78636$export$fa7daccca11cdbe3();
const $d5b85d29c0b78636$var$_v42 = /*@__PURE__*/ new $d5b85d29c0b78636$export$fa7daccca11cdbe3();
class $d5b85d29c0b78636$export$5a465592bfe74b48 {
    constructor(a = new $d5b85d29c0b78636$export$64b5c384219d3699(), b = new $d5b85d29c0b78636$export$64b5c384219d3699(), c = new $d5b85d29c0b78636$export$64b5c384219d3699()){
        this.a = a;
        this.b = b;
        this.c = c;
    }
    static getNormal(a, b, c, target) {
        target.subVectors(c, b);
        $d5b85d29c0b78636$var$_v0$1.subVectors(a, b);
        target.cross($d5b85d29c0b78636$var$_v0$1);
        const targetLengthSq = target.lengthSq();
        if (targetLengthSq > 0) return target.multiplyScalar(1 / Math.sqrt(targetLengthSq));
        return target.set(0, 0, 0);
    }
    // static/instance method to calculate barycentric coordinates
    // based on: http://www.blackpawn.com/texts/pointinpoly/default.html
    static getBarycoord(point, a, b, c, target) {
        $d5b85d29c0b78636$var$_v0$1.subVectors(c, a);
        $d5b85d29c0b78636$var$_v1$3.subVectors(b, a);
        $d5b85d29c0b78636$var$_v2$2.subVectors(point, a);
        const dot00 = $d5b85d29c0b78636$var$_v0$1.dot($d5b85d29c0b78636$var$_v0$1);
        const dot01 = $d5b85d29c0b78636$var$_v0$1.dot($d5b85d29c0b78636$var$_v1$3);
        const dot02 = $d5b85d29c0b78636$var$_v0$1.dot($d5b85d29c0b78636$var$_v2$2);
        const dot11 = $d5b85d29c0b78636$var$_v1$3.dot($d5b85d29c0b78636$var$_v1$3);
        const dot12 = $d5b85d29c0b78636$var$_v1$3.dot($d5b85d29c0b78636$var$_v2$2);
        const denom = dot00 * dot11 - dot01 * dot01;
        // collinear or singular triangle
        if (denom === 0) {
            target.set(0, 0, 0);
            return null;
        }
        const invDenom = 1 / denom;
        const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
        const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
        // barycentric coordinates must always sum to 1
        return target.set(1 - u - v, v, u);
    }
    static containsPoint(point, a, b, c) {
        // if the triangle is degenerate then we can't contain a point
        if (this.getBarycoord(point, a, b, c, $d5b85d29c0b78636$var$_v3$2) === null) return false;
        return $d5b85d29c0b78636$var$_v3$2.x >= 0 && $d5b85d29c0b78636$var$_v3$2.y >= 0 && $d5b85d29c0b78636$var$_v3$2.x + $d5b85d29c0b78636$var$_v3$2.y <= 1;
    }
    static getInterpolation(point, p1, p2, p3, v1, v2, v3, target) {
        if (this.getBarycoord(point, p1, p2, p3, $d5b85d29c0b78636$var$_v3$2) === null) {
            target.x = 0;
            target.y = 0;
            if ('z' in target) target.z = 0;
            if ('w' in target) target.w = 0;
            return null;
        }
        target.setScalar(0);
        target.addScaledVector(v1, $d5b85d29c0b78636$var$_v3$2.x);
        target.addScaledVector(v2, $d5b85d29c0b78636$var$_v3$2.y);
        target.addScaledVector(v3, $d5b85d29c0b78636$var$_v3$2.z);
        return target;
    }
    static getInterpolatedAttribute(attr, i1, i2, i3, barycoord, target) {
        $d5b85d29c0b78636$var$_v40.setScalar(0);
        $d5b85d29c0b78636$var$_v41.setScalar(0);
        $d5b85d29c0b78636$var$_v42.setScalar(0);
        $d5b85d29c0b78636$var$_v40.fromBufferAttribute(attr, i1);
        $d5b85d29c0b78636$var$_v41.fromBufferAttribute(attr, i2);
        $d5b85d29c0b78636$var$_v42.fromBufferAttribute(attr, i3);
        target.setScalar(0);
        target.addScaledVector($d5b85d29c0b78636$var$_v40, barycoord.x);
        target.addScaledVector($d5b85d29c0b78636$var$_v41, barycoord.y);
        target.addScaledVector($d5b85d29c0b78636$var$_v42, barycoord.z);
        return target;
    }
    static isFrontFacing(a, b, c, direction) {
        $d5b85d29c0b78636$var$_v0$1.subVectors(c, b);
        $d5b85d29c0b78636$var$_v1$3.subVectors(a, b);
        // strictly front facing
        return $d5b85d29c0b78636$var$_v0$1.cross($d5b85d29c0b78636$var$_v1$3).dot(direction) < 0 ? true : false;
    }
    set(a, b, c) {
        this.a.copy(a);
        this.b.copy(b);
        this.c.copy(c);
        return this;
    }
    setFromPointsAndIndices(points, i0, i1, i2) {
        this.a.copy(points[i0]);
        this.b.copy(points[i1]);
        this.c.copy(points[i2]);
        return this;
    }
    setFromAttributeAndIndices(attribute, i0, i1, i2) {
        this.a.fromBufferAttribute(attribute, i0);
        this.b.fromBufferAttribute(attribute, i1);
        this.c.fromBufferAttribute(attribute, i2);
        return this;
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(triangle) {
        this.a.copy(triangle.a);
        this.b.copy(triangle.b);
        this.c.copy(triangle.c);
        return this;
    }
    getArea() {
        $d5b85d29c0b78636$var$_v0$1.subVectors(this.c, this.b);
        $d5b85d29c0b78636$var$_v1$3.subVectors(this.a, this.b);
        return $d5b85d29c0b78636$var$_v0$1.cross($d5b85d29c0b78636$var$_v1$3).length() * 0.5;
    }
    getMidpoint(target) {
        return target.addVectors(this.a, this.b).add(this.c).multiplyScalar(1 / 3);
    }
    getNormal(target) {
        return $d5b85d29c0b78636$export$5a465592bfe74b48.getNormal(this.a, this.b, this.c, target);
    }
    getPlane(target) {
        return target.setFromCoplanarPoints(this.a, this.b, this.c);
    }
    getBarycoord(point, target) {
        return $d5b85d29c0b78636$export$5a465592bfe74b48.getBarycoord(point, this.a, this.b, this.c, target);
    }
    getInterpolation(point, v1, v2, v3, target) {
        return $d5b85d29c0b78636$export$5a465592bfe74b48.getInterpolation(point, this.a, this.b, this.c, v1, v2, v3, target);
    }
    containsPoint(point) {
        return $d5b85d29c0b78636$export$5a465592bfe74b48.containsPoint(point, this.a, this.b, this.c);
    }
    isFrontFacing(direction) {
        return $d5b85d29c0b78636$export$5a465592bfe74b48.isFrontFacing(this.a, this.b, this.c, direction);
    }
    intersectsBox(box) {
        return box.intersectsTriangle(this);
    }
    closestPointToPoint(p, target) {
        const a = this.a, b = this.b, c = this.c;
        let v, w;
        // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
        // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
        // under the accompanying license; see chapter 5.1.5 for detailed explanation.
        // basically, we're distinguishing which of the voronoi regions of the triangle
        // the point lies in with the minimum amount of redundant computation.
        $d5b85d29c0b78636$var$_vab.subVectors(b, a);
        $d5b85d29c0b78636$var$_vac.subVectors(c, a);
        $d5b85d29c0b78636$var$_vap.subVectors(p, a);
        const d1 = $d5b85d29c0b78636$var$_vab.dot($d5b85d29c0b78636$var$_vap);
        const d2 = $d5b85d29c0b78636$var$_vac.dot($d5b85d29c0b78636$var$_vap);
        if (d1 <= 0 && d2 <= 0) // vertex region of A; barycentric coords (1, 0, 0)
        return target.copy(a);
        $d5b85d29c0b78636$var$_vbp.subVectors(p, b);
        const d3 = $d5b85d29c0b78636$var$_vab.dot($d5b85d29c0b78636$var$_vbp);
        const d4 = $d5b85d29c0b78636$var$_vac.dot($d5b85d29c0b78636$var$_vbp);
        if (d3 >= 0 && d4 <= d3) // vertex region of B; barycentric coords (0, 1, 0)
        return target.copy(b);
        const vc = d1 * d4 - d3 * d2;
        if (vc <= 0 && d1 >= 0 && d3 <= 0) {
            v = d1 / (d1 - d3);
            // edge region of AB; barycentric coords (1-v, v, 0)
            return target.copy(a).addScaledVector($d5b85d29c0b78636$var$_vab, v);
        }
        $d5b85d29c0b78636$var$_vcp.subVectors(p, c);
        const d5 = $d5b85d29c0b78636$var$_vab.dot($d5b85d29c0b78636$var$_vcp);
        const d6 = $d5b85d29c0b78636$var$_vac.dot($d5b85d29c0b78636$var$_vcp);
        if (d6 >= 0 && d5 <= d6) // vertex region of C; barycentric coords (0, 0, 1)
        return target.copy(c);
        const vb = d5 * d2 - d1 * d6;
        if (vb <= 0 && d2 >= 0 && d6 <= 0) {
            w = d2 / (d2 - d6);
            // edge region of AC; barycentric coords (1-w, 0, w)
            return target.copy(a).addScaledVector($d5b85d29c0b78636$var$_vac, w);
        }
        const va = d3 * d6 - d5 * d4;
        if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
            $d5b85d29c0b78636$var$_vbc.subVectors(c, b);
            w = (d4 - d3) / (d4 - d3 + (d5 - d6));
            // edge region of BC; barycentric coords (0, 1-w, w)
            return target.copy(b).addScaledVector($d5b85d29c0b78636$var$_vbc, w); // edge region of BC
        }
        // face region
        const denom = 1 / (va + vb + vc);
        // u = va * denom
        v = vb * denom;
        w = vc * denom;
        return target.copy(a).addScaledVector($d5b85d29c0b78636$var$_vab, v).addScaledVector($d5b85d29c0b78636$var$_vac, w);
    }
    equals(triangle) {
        return triangle.a.equals(this.a) && triangle.b.equals(this.b) && triangle.c.equals(this.c);
    }
}
const $d5b85d29c0b78636$var$_colorKeywords = {
    'aliceblue': 0xF0F8FF,
    'antiquewhite': 0xFAEBD7,
    'aqua': 0x00FFFF,
    'aquamarine': 0x7FFFD4,
    'azure': 0xF0FFFF,
    'beige': 0xF5F5DC,
    'bisque': 0xFFE4C4,
    'black': 0x000000,
    'blanchedalmond': 0xFFEBCD,
    'blue': 0x0000FF,
    'blueviolet': 0x8A2BE2,
    'brown': 0xA52A2A,
    'burlywood': 0xDEB887,
    'cadetblue': 0x5F9EA0,
    'chartreuse': 0x7FFF00,
    'chocolate': 0xD2691E,
    'coral': 0xFF7F50,
    'cornflowerblue': 0x6495ED,
    'cornsilk': 0xFFF8DC,
    'crimson': 0xDC143C,
    'cyan': 0x00FFFF,
    'darkblue': 0x00008B,
    'darkcyan': 0x008B8B,
    'darkgoldenrod': 0xB8860B,
    'darkgray': 0xA9A9A9,
    'darkgreen': 0x006400,
    'darkgrey': 0xA9A9A9,
    'darkkhaki': 0xBDB76B,
    'darkmagenta': 0x8B008B,
    'darkolivegreen': 0x556B2F,
    'darkorange': 0xFF8C00,
    'darkorchid': 0x9932CC,
    'darkred': 0x8B0000,
    'darksalmon': 0xE9967A,
    'darkseagreen': 0x8FBC8F,
    'darkslateblue': 0x483D8B,
    'darkslategray': 0x2F4F4F,
    'darkslategrey': 0x2F4F4F,
    'darkturquoise': 0x00CED1,
    'darkviolet': 0x9400D3,
    'deeppink': 0xFF1493,
    'deepskyblue': 0x00BFFF,
    'dimgray': 0x696969,
    'dimgrey': 0x696969,
    'dodgerblue': 0x1E90FF,
    'firebrick': 0xB22222,
    'floralwhite': 0xFFFAF0,
    'forestgreen': 0x228B22,
    'fuchsia': 0xFF00FF,
    'gainsboro': 0xDCDCDC,
    'ghostwhite': 0xF8F8FF,
    'gold': 0xFFD700,
    'goldenrod': 0xDAA520,
    'gray': 0x808080,
    'green': 0x008000,
    'greenyellow': 0xADFF2F,
    'grey': 0x808080,
    'honeydew': 0xF0FFF0,
    'hotpink': 0xFF69B4,
    'indianred': 0xCD5C5C,
    'indigo': 0x4B0082,
    'ivory': 0xFFFFF0,
    'khaki': 0xF0E68C,
    'lavender': 0xE6E6FA,
    'lavenderblush': 0xFFF0F5,
    'lawngreen': 0x7CFC00,
    'lemonchiffon': 0xFFFACD,
    'lightblue': 0xADD8E6,
    'lightcoral': 0xF08080,
    'lightcyan': 0xE0FFFF,
    'lightgoldenrodyellow': 0xFAFAD2,
    'lightgray': 0xD3D3D3,
    'lightgreen': 0x90EE90,
    'lightgrey': 0xD3D3D3,
    'lightpink': 0xFFB6C1,
    'lightsalmon': 0xFFA07A,
    'lightseagreen': 0x20B2AA,
    'lightskyblue': 0x87CEFA,
    'lightslategray': 0x778899,
    'lightslategrey': 0x778899,
    'lightsteelblue': 0xB0C4DE,
    'lightyellow': 0xFFFFE0,
    'lime': 0x00FF00,
    'limegreen': 0x32CD32,
    'linen': 0xFAF0E6,
    'magenta': 0xFF00FF,
    'maroon': 0x800000,
    'mediumaquamarine': 0x66CDAA,
    'mediumblue': 0x0000CD,
    'mediumorchid': 0xBA55D3,
    'mediumpurple': 0x9370DB,
    'mediumseagreen': 0x3CB371,
    'mediumslateblue': 0x7B68EE,
    'mediumspringgreen': 0x00FA9A,
    'mediumturquoise': 0x48D1CC,
    'mediumvioletred': 0xC71585,
    'midnightblue': 0x191970,
    'mintcream': 0xF5FFFA,
    'mistyrose': 0xFFE4E1,
    'moccasin': 0xFFE4B5,
    'navajowhite': 0xFFDEAD,
    'navy': 0x000080,
    'oldlace': 0xFDF5E6,
    'olive': 0x808000,
    'olivedrab': 0x6B8E23,
    'orange': 0xFFA500,
    'orangered': 0xFF4500,
    'orchid': 0xDA70D6,
    'palegoldenrod': 0xEEE8AA,
    'palegreen': 0x98FB98,
    'paleturquoise': 0xAFEEEE,
    'palevioletred': 0xDB7093,
    'papayawhip': 0xFFEFD5,
    'peachpuff': 0xFFDAB9,
    'peru': 0xCD853F,
    'pink': 0xFFC0CB,
    'plum': 0xDDA0DD,
    'powderblue': 0xB0E0E6,
    'purple': 0x800080,
    'rebeccapurple': 0x663399,
    'red': 0xFF0000,
    'rosybrown': 0xBC8F8F,
    'royalblue': 0x4169E1,
    'saddlebrown': 0x8B4513,
    'salmon': 0xFA8072,
    'sandybrown': 0xF4A460,
    'seagreen': 0x2E8B57,
    'seashell': 0xFFF5EE,
    'sienna': 0xA0522D,
    'silver': 0xC0C0C0,
    'skyblue': 0x87CEEB,
    'slateblue': 0x6A5ACD,
    'slategray': 0x708090,
    'slategrey': 0x708090,
    'snow': 0xFFFAFA,
    'springgreen': 0x00FF7F,
    'steelblue': 0x4682B4,
    'tan': 0xD2B48C,
    'teal': 0x008080,
    'thistle': 0xD8BFD8,
    'tomato': 0xFF6347,
    'turquoise': 0x40E0D0,
    'violet': 0xEE82EE,
    'wheat': 0xF5DEB3,
    'white': 0xFFFFFF,
    'whitesmoke': 0xF5F5F5,
    'yellow': 0xFFFF00,
    'yellowgreen': 0x9ACD32
};
const $d5b85d29c0b78636$var$_hslA = {
    h: 0,
    s: 0,
    l: 0
};
const $d5b85d29c0b78636$var$_hslB = {
    h: 0,
    s: 0,
    l: 0
};
function $d5b85d29c0b78636$var$hue2rgb(p, q, t) {
    if (t < 0) t += 1;
    if (t > 1) t -= 1;
    if (t < 1 / 6) return p + (q - p) * 6 * t;
    if (t < 0.5) return q;
    if (t < 2 / 3) return p + (q - p) * 6 * (2 / 3 - t);
    return p;
}
class $d5b85d29c0b78636$export$892596cec99bc70e {
    constructor(r, g, b){
        this.isColor = true;
        this.r = 1;
        this.g = 1;
        this.b = 1;
        return this.set(r, g, b);
    }
    set(r, g, b) {
        if (g === undefined && b === undefined) {
            // r is THREE.Color, hex or string
            const value = r;
            if (value && value.isColor) this.copy(value);
            else if (typeof value === 'number') this.setHex(value);
            else if (typeof value === 'string') this.setStyle(value);
        } else this.setRGB(r, g, b);
        return this;
    }
    setScalar(scalar) {
        this.r = scalar;
        this.g = scalar;
        this.b = scalar;
        return this;
    }
    setHex(hex, colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa) {
        hex = Math.floor(hex);
        this.r = (hex >> 16 & 255) / 255;
        this.g = (hex >> 8 & 255) / 255;
        this.b = (hex & 255) / 255;
        $d5b85d29c0b78636$export$5e6fd513f44698c.toWorkingColorSpace(this, colorSpace);
        return this;
    }
    setRGB(r, g, b, colorSpace = $d5b85d29c0b78636$export$5e6fd513f44698c.workingColorSpace) {
        this.r = r;
        this.g = g;
        this.b = b;
        $d5b85d29c0b78636$export$5e6fd513f44698c.toWorkingColorSpace(this, colorSpace);
        return this;
    }
    setHSL(h, s, l, colorSpace = $d5b85d29c0b78636$export$5e6fd513f44698c.workingColorSpace) {
        // h,s,l ranges are in 0.0 - 1.0
        h = $d5b85d29c0b78636$var$euclideanModulo(h, 1);
        s = $d5b85d29c0b78636$var$clamp(s, 0, 1);
        l = $d5b85d29c0b78636$var$clamp(l, 0, 1);
        if (s === 0) this.r = this.g = this.b = l;
        else {
            const p = l <= 0.5 ? l * (1 + s) : l + s - l * s;
            const q = 2 * l - p;
            this.r = $d5b85d29c0b78636$var$hue2rgb(q, p, h + 1 / 3);
            this.g = $d5b85d29c0b78636$var$hue2rgb(q, p, h);
            this.b = $d5b85d29c0b78636$var$hue2rgb(q, p, h - 1 / 3);
        }
        $d5b85d29c0b78636$export$5e6fd513f44698c.toWorkingColorSpace(this, colorSpace);
        return this;
    }
    setStyle(style, colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa) {
        function handleAlpha(string) {
            if (string === undefined) return;
            if (parseFloat(string) < 1) console.warn('THREE.Color: Alpha component of ' + style + ' will be ignored.');
        }
        let m;
        if (m = /^(\w+)\(([^\)]*)\)/.exec(style)) {
            // rgb / hsl
            let color;
            const name = m[1];
            const components = m[2];
            switch(name){
                case 'rgb':
                case 'rgba':
                    if (color = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
                        // rgb(255,0,0) rgba(255,0,0,0.5)
                        handleAlpha(color[4]);
                        return this.setRGB(Math.min(255, parseInt(color[1], 10)) / 255, Math.min(255, parseInt(color[2], 10)) / 255, Math.min(255, parseInt(color[3], 10)) / 255, colorSpace);
                    }
                    if (color = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
                        // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
                        handleAlpha(color[4]);
                        return this.setRGB(Math.min(100, parseInt(color[1], 10)) / 100, Math.min(100, parseInt(color[2], 10)) / 100, Math.min(100, parseInt(color[3], 10)) / 100, colorSpace);
                    }
                    break;
                case 'hsl':
                case 'hsla':
                    if (color = /^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(components)) {
                        // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
                        handleAlpha(color[4]);
                        return this.setHSL(parseFloat(color[1]) / 360, parseFloat(color[2]) / 100, parseFloat(color[3]) / 100, colorSpace);
                    }
                    break;
                default:
                    console.warn('THREE.Color: Unknown color model ' + style);
            }
        } else if (m = /^\#([A-Fa-f\d]+)$/.exec(style)) {
            // hex color
            const hex = m[1];
            const size = hex.length;
            if (size === 3) // #ff0
            return this.setRGB(parseInt(hex.charAt(0), 16) / 15, parseInt(hex.charAt(1), 16) / 15, parseInt(hex.charAt(2), 16) / 15, colorSpace);
            else if (size === 6) // #ff0000
            return this.setHex(parseInt(hex, 16), colorSpace);
            else console.warn('THREE.Color: Invalid hex color ' + style);
        } else if (style && style.length > 0) return this.setColorName(style, colorSpace);
        return this;
    }
    setColorName(style, colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa) {
        // color keywords
        const hex = $d5b85d29c0b78636$var$_colorKeywords[style.toLowerCase()];
        if (hex !== undefined) // red
        this.setHex(hex, colorSpace);
        else // unknown color
        console.warn('THREE.Color: Unknown color ' + style);
        return this;
    }
    clone() {
        return new this.constructor(this.r, this.g, this.b);
    }
    copy(color) {
        this.r = color.r;
        this.g = color.g;
        this.b = color.b;
        return this;
    }
    copySRGBToLinear(color) {
        this.r = $d5b85d29c0b78636$var$SRGBToLinear(color.r);
        this.g = $d5b85d29c0b78636$var$SRGBToLinear(color.g);
        this.b = $d5b85d29c0b78636$var$SRGBToLinear(color.b);
        return this;
    }
    copyLinearToSRGB(color) {
        this.r = $d5b85d29c0b78636$var$LinearToSRGB(color.r);
        this.g = $d5b85d29c0b78636$var$LinearToSRGB(color.g);
        this.b = $d5b85d29c0b78636$var$LinearToSRGB(color.b);
        return this;
    }
    convertSRGBToLinear() {
        this.copySRGBToLinear(this);
        return this;
    }
    convertLinearToSRGB() {
        this.copyLinearToSRGB(this);
        return this;
    }
    getHex(colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa) {
        $d5b85d29c0b78636$export$5e6fd513f44698c.fromWorkingColorSpace($d5b85d29c0b78636$var$_color.copy(this), colorSpace);
        return Math.round($d5b85d29c0b78636$var$clamp($d5b85d29c0b78636$var$_color.r * 255, 0, 255)) * 65536 + Math.round($d5b85d29c0b78636$var$clamp($d5b85d29c0b78636$var$_color.g * 255, 0, 255)) * 256 + Math.round($d5b85d29c0b78636$var$clamp($d5b85d29c0b78636$var$_color.b * 255, 0, 255));
    }
    getHexString(colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa) {
        return ('000000' + this.getHex(colorSpace).toString(16)).slice(-6);
    }
    getHSL(target, colorSpace = $d5b85d29c0b78636$export$5e6fd513f44698c.workingColorSpace) {
        // h,s,l ranges are in 0.0 - 1.0
        $d5b85d29c0b78636$export$5e6fd513f44698c.fromWorkingColorSpace($d5b85d29c0b78636$var$_color.copy(this), colorSpace);
        const r = $d5b85d29c0b78636$var$_color.r, g = $d5b85d29c0b78636$var$_color.g, b = $d5b85d29c0b78636$var$_color.b;
        const max = Math.max(r, g, b);
        const min = Math.min(r, g, b);
        let hue, saturation;
        const lightness = (min + max) / 2.0;
        if (min === max) {
            hue = 0;
            saturation = 0;
        } else {
            const delta = max - min;
            saturation = lightness <= 0.5 ? delta / (max + min) : delta / (2 - max - min);
            switch(max){
                case r:
                    hue = (g - b) / delta + (g < b ? 6 : 0);
                    break;
                case g:
                    hue = (b - r) / delta + 2;
                    break;
                case b:
                    hue = (r - g) / delta + 4;
                    break;
            }
            hue /= 6;
        }
        target.h = hue;
        target.s = saturation;
        target.l = lightness;
        return target;
    }
    getRGB(target, colorSpace = $d5b85d29c0b78636$export$5e6fd513f44698c.workingColorSpace) {
        $d5b85d29c0b78636$export$5e6fd513f44698c.fromWorkingColorSpace($d5b85d29c0b78636$var$_color.copy(this), colorSpace);
        target.r = $d5b85d29c0b78636$var$_color.r;
        target.g = $d5b85d29c0b78636$var$_color.g;
        target.b = $d5b85d29c0b78636$var$_color.b;
        return target;
    }
    getStyle(colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa) {
        $d5b85d29c0b78636$export$5e6fd513f44698c.fromWorkingColorSpace($d5b85d29c0b78636$var$_color.copy(this), colorSpace);
        const r = $d5b85d29c0b78636$var$_color.r, g = $d5b85d29c0b78636$var$_color.g, b = $d5b85d29c0b78636$var$_color.b;
        if (colorSpace !== $d5b85d29c0b78636$export$561f394b24edfcaa) // Requires CSS Color Module Level 4 (https://www.w3.org/TR/css-color-4/).
        return `color(${colorSpace} ${r.toFixed(3)} ${g.toFixed(3)} ${b.toFixed(3)})`;
        return `rgb(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)})`;
    }
    offsetHSL(h, s, l) {
        this.getHSL($d5b85d29c0b78636$var$_hslA);
        return this.setHSL($d5b85d29c0b78636$var$_hslA.h + h, $d5b85d29c0b78636$var$_hslA.s + s, $d5b85d29c0b78636$var$_hslA.l + l);
    }
    add(color) {
        this.r += color.r;
        this.g += color.g;
        this.b += color.b;
        return this;
    }
    addColors(color1, color2) {
        this.r = color1.r + color2.r;
        this.g = color1.g + color2.g;
        this.b = color1.b + color2.b;
        return this;
    }
    addScalar(s) {
        this.r += s;
        this.g += s;
        this.b += s;
        return this;
    }
    sub(color) {
        this.r = Math.max(0, this.r - color.r);
        this.g = Math.max(0, this.g - color.g);
        this.b = Math.max(0, this.b - color.b);
        return this;
    }
    multiply(color) {
        this.r *= color.r;
        this.g *= color.g;
        this.b *= color.b;
        return this;
    }
    multiplyScalar(s) {
        this.r *= s;
        this.g *= s;
        this.b *= s;
        return this;
    }
    lerp(color, alpha) {
        this.r += (color.r - this.r) * alpha;
        this.g += (color.g - this.g) * alpha;
        this.b += (color.b - this.b) * alpha;
        return this;
    }
    lerpColors(color1, color2, alpha) {
        this.r = color1.r + (color2.r - color1.r) * alpha;
        this.g = color1.g + (color2.g - color1.g) * alpha;
        this.b = color1.b + (color2.b - color1.b) * alpha;
        return this;
    }
    lerpHSL(color, alpha) {
        this.getHSL($d5b85d29c0b78636$var$_hslA);
        color.getHSL($d5b85d29c0b78636$var$_hslB);
        const h = $d5b85d29c0b78636$var$lerp($d5b85d29c0b78636$var$_hslA.h, $d5b85d29c0b78636$var$_hslB.h, alpha);
        const s = $d5b85d29c0b78636$var$lerp($d5b85d29c0b78636$var$_hslA.s, $d5b85d29c0b78636$var$_hslB.s, alpha);
        const l = $d5b85d29c0b78636$var$lerp($d5b85d29c0b78636$var$_hslA.l, $d5b85d29c0b78636$var$_hslB.l, alpha);
        this.setHSL(h, s, l);
        return this;
    }
    setFromVector3(v) {
        this.r = v.x;
        this.g = v.y;
        this.b = v.z;
        return this;
    }
    applyMatrix3(m) {
        const r = this.r, g = this.g, b = this.b;
        const e = m.elements;
        this.r = e[0] * r + e[3] * g + e[6] * b;
        this.g = e[1] * r + e[4] * g + e[7] * b;
        this.b = e[2] * r + e[5] * g + e[8] * b;
        return this;
    }
    equals(c) {
        return c.r === this.r && c.g === this.g && c.b === this.b;
    }
    fromArray(array, offset = 0) {
        this.r = array[offset];
        this.g = array[offset + 1];
        this.b = array[offset + 2];
        return this;
    }
    toArray(array = [], offset = 0) {
        array[offset] = this.r;
        array[offset + 1] = this.g;
        array[offset + 2] = this.b;
        return array;
    }
    fromBufferAttribute(attribute, index) {
        this.r = attribute.getX(index);
        this.g = attribute.getY(index);
        this.b = attribute.getZ(index);
        return this;
    }
    toJSON() {
        return this.getHex();
    }
    *[Symbol.iterator]() {
        yield this.r;
        yield this.g;
        yield this.b;
    }
}
const $d5b85d29c0b78636$var$_color = /*@__PURE__*/ new $d5b85d29c0b78636$export$892596cec99bc70e();
$d5b85d29c0b78636$export$892596cec99bc70e.NAMES = $d5b85d29c0b78636$var$_colorKeywords;
let $d5b85d29c0b78636$var$_materialId = 0;
class $d5b85d29c0b78636$export$a2d8b23205c25948 extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(){
        super();
        this.isMaterial = true;
        Object.defineProperty(this, 'id', {
            value: $d5b85d29c0b78636$var$_materialId++
        });
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.name = '';
        this.type = 'Material';
        this.blending = $d5b85d29c0b78636$export$5b29a26d96ee6af0;
        this.side = $d5b85d29c0b78636$export$2ede184fc2998901;
        this.vertexColors = false;
        this.opacity = 1;
        this.transparent = false;
        this.alphaHash = false;
        this.blendSrc = $d5b85d29c0b78636$export$d5773124e86cf28c;
        this.blendDst = $d5b85d29c0b78636$export$11d468cc7f19e971;
        this.blendEquation = $d5b85d29c0b78636$export$20183a0484ce21a0;
        this.blendSrcAlpha = null;
        this.blendDstAlpha = null;
        this.blendEquationAlpha = null;
        this.blendColor = new $d5b85d29c0b78636$export$892596cec99bc70e(0, 0, 0);
        this.blendAlpha = 0;
        this.depthFunc = $d5b85d29c0b78636$export$296f78a0b892f81a;
        this.depthTest = true;
        this.depthWrite = true;
        this.stencilWriteMask = 0xff;
        this.stencilFunc = $d5b85d29c0b78636$export$14cf96713ddd97a8;
        this.stencilRef = 0;
        this.stencilFuncMask = 0xff;
        this.stencilFail = $d5b85d29c0b78636$export$9f542ae4b5baca34;
        this.stencilZFail = $d5b85d29c0b78636$export$9f542ae4b5baca34;
        this.stencilZPass = $d5b85d29c0b78636$export$9f542ae4b5baca34;
        this.stencilWrite = false;
        this.clippingPlanes = null;
        this.clipIntersection = false;
        this.clipShadows = false;
        this.shadowSide = null;
        this.colorWrite = true;
        this.precision = null; // override the renderer's default precision for this material
        this.polygonOffset = false;
        this.polygonOffsetFactor = 0;
        this.polygonOffsetUnits = 0;
        this.dithering = false;
        this.alphaToCoverage = false;
        this.premultipliedAlpha = false;
        this.forceSinglePass = false;
        this.visible = true;
        this.toneMapped = true;
        this.userData = {};
        this.version = 0;
        this._alphaTest = 0;
    }
    get alphaTest() {
        return this._alphaTest;
    }
    set alphaTest(value) {
        if (this._alphaTest > 0 !== value > 0) this.version++;
        this._alphaTest = value;
    }
    // onBeforeRender and onBeforeCompile only supported in WebGLRenderer
    onBeforeRender() {}
    onBeforeCompile() {}
    customProgramCacheKey() {
        return this.onBeforeCompile.toString();
    }
    setValues(values) {
        if (values === undefined) return;
        for(const key in values){
            const newValue = values[key];
            if (newValue === undefined) {
                console.warn(`THREE.Material: parameter '${key}' has value of undefined.`);
                continue;
            }
            const currentValue = this[key];
            if (currentValue === undefined) {
                console.warn(`THREE.Material: '${key}' is not a property of THREE.${this.type}.`);
                continue;
            }
            if (currentValue && currentValue.isColor) currentValue.set(newValue);
            else if (currentValue && currentValue.isVector3 && newValue && newValue.isVector3) currentValue.copy(newValue);
            else this[key] = newValue;
        }
    }
    toJSON(meta) {
        const isRootObject = meta === undefined || typeof meta === 'string';
        if (isRootObject) meta = {
            textures: {},
            images: {}
        };
        const data = {
            metadata: {
                version: 4.6,
                type: 'Material',
                generator: 'Material.toJSON'
            }
        };
        // standard Material serialization
        data.uuid = this.uuid;
        data.type = this.type;
        if (this.name !== '') data.name = this.name;
        if (this.color && this.color.isColor) data.color = this.color.getHex();
        if (this.roughness !== undefined) data.roughness = this.roughness;
        if (this.metalness !== undefined) data.metalness = this.metalness;
        if (this.sheen !== undefined) data.sheen = this.sheen;
        if (this.sheenColor && this.sheenColor.isColor) data.sheenColor = this.sheenColor.getHex();
        if (this.sheenRoughness !== undefined) data.sheenRoughness = this.sheenRoughness;
        if (this.emissive && this.emissive.isColor) data.emissive = this.emissive.getHex();
        if (this.emissiveIntensity !== undefined && this.emissiveIntensity !== 1) data.emissiveIntensity = this.emissiveIntensity;
        if (this.specular && this.specular.isColor) data.specular = this.specular.getHex();
        if (this.specularIntensity !== undefined) data.specularIntensity = this.specularIntensity;
        if (this.specularColor && this.specularColor.isColor) data.specularColor = this.specularColor.getHex();
        if (this.shininess !== undefined) data.shininess = this.shininess;
        if (this.clearcoat !== undefined) data.clearcoat = this.clearcoat;
        if (this.clearcoatRoughness !== undefined) data.clearcoatRoughness = this.clearcoatRoughness;
        if (this.clearcoatMap && this.clearcoatMap.isTexture) data.clearcoatMap = this.clearcoatMap.toJSON(meta).uuid;
        if (this.clearcoatRoughnessMap && this.clearcoatRoughnessMap.isTexture) data.clearcoatRoughnessMap = this.clearcoatRoughnessMap.toJSON(meta).uuid;
        if (this.clearcoatNormalMap && this.clearcoatNormalMap.isTexture) {
            data.clearcoatNormalMap = this.clearcoatNormalMap.toJSON(meta).uuid;
            data.clearcoatNormalScale = this.clearcoatNormalScale.toArray();
        }
        if (this.dispersion !== undefined) data.dispersion = this.dispersion;
        if (this.iridescence !== undefined) data.iridescence = this.iridescence;
        if (this.iridescenceIOR !== undefined) data.iridescenceIOR = this.iridescenceIOR;
        if (this.iridescenceThicknessRange !== undefined) data.iridescenceThicknessRange = this.iridescenceThicknessRange;
        if (this.iridescenceMap && this.iridescenceMap.isTexture) data.iridescenceMap = this.iridescenceMap.toJSON(meta).uuid;
        if (this.iridescenceThicknessMap && this.iridescenceThicknessMap.isTexture) data.iridescenceThicknessMap = this.iridescenceThicknessMap.toJSON(meta).uuid;
        if (this.anisotropy !== undefined) data.anisotropy = this.anisotropy;
        if (this.anisotropyRotation !== undefined) data.anisotropyRotation = this.anisotropyRotation;
        if (this.anisotropyMap && this.anisotropyMap.isTexture) data.anisotropyMap = this.anisotropyMap.toJSON(meta).uuid;
        if (this.map && this.map.isTexture) data.map = this.map.toJSON(meta).uuid;
        if (this.matcap && this.matcap.isTexture) data.matcap = this.matcap.toJSON(meta).uuid;
        if (this.alphaMap && this.alphaMap.isTexture) data.alphaMap = this.alphaMap.toJSON(meta).uuid;
        if (this.lightMap && this.lightMap.isTexture) {
            data.lightMap = this.lightMap.toJSON(meta).uuid;
            data.lightMapIntensity = this.lightMapIntensity;
        }
        if (this.aoMap && this.aoMap.isTexture) {
            data.aoMap = this.aoMap.toJSON(meta).uuid;
            data.aoMapIntensity = this.aoMapIntensity;
        }
        if (this.bumpMap && this.bumpMap.isTexture) {
            data.bumpMap = this.bumpMap.toJSON(meta).uuid;
            data.bumpScale = this.bumpScale;
        }
        if (this.normalMap && this.normalMap.isTexture) {
            data.normalMap = this.normalMap.toJSON(meta).uuid;
            data.normalMapType = this.normalMapType;
            data.normalScale = this.normalScale.toArray();
        }
        if (this.displacementMap && this.displacementMap.isTexture) {
            data.displacementMap = this.displacementMap.toJSON(meta).uuid;
            data.displacementScale = this.displacementScale;
            data.displacementBias = this.displacementBias;
        }
        if (this.roughnessMap && this.roughnessMap.isTexture) data.roughnessMap = this.roughnessMap.toJSON(meta).uuid;
        if (this.metalnessMap && this.metalnessMap.isTexture) data.metalnessMap = this.metalnessMap.toJSON(meta).uuid;
        if (this.emissiveMap && this.emissiveMap.isTexture) data.emissiveMap = this.emissiveMap.toJSON(meta).uuid;
        if (this.specularMap && this.specularMap.isTexture) data.specularMap = this.specularMap.toJSON(meta).uuid;
        if (this.specularIntensityMap && this.specularIntensityMap.isTexture) data.specularIntensityMap = this.specularIntensityMap.toJSON(meta).uuid;
        if (this.specularColorMap && this.specularColorMap.isTexture) data.specularColorMap = this.specularColorMap.toJSON(meta).uuid;
        if (this.envMap && this.envMap.isTexture) {
            data.envMap = this.envMap.toJSON(meta).uuid;
            if (this.combine !== undefined) data.combine = this.combine;
        }
        if (this.envMapRotation !== undefined) data.envMapRotation = this.envMapRotation.toArray();
        if (this.envMapIntensity !== undefined) data.envMapIntensity = this.envMapIntensity;
        if (this.reflectivity !== undefined) data.reflectivity = this.reflectivity;
        if (this.refractionRatio !== undefined) data.refractionRatio = this.refractionRatio;
        if (this.gradientMap && this.gradientMap.isTexture) data.gradientMap = this.gradientMap.toJSON(meta).uuid;
        if (this.transmission !== undefined) data.transmission = this.transmission;
        if (this.transmissionMap && this.transmissionMap.isTexture) data.transmissionMap = this.transmissionMap.toJSON(meta).uuid;
        if (this.thickness !== undefined) data.thickness = this.thickness;
        if (this.thicknessMap && this.thicknessMap.isTexture) data.thicknessMap = this.thicknessMap.toJSON(meta).uuid;
        if (this.attenuationDistance !== undefined && this.attenuationDistance !== Infinity) data.attenuationDistance = this.attenuationDistance;
        if (this.attenuationColor !== undefined) data.attenuationColor = this.attenuationColor.getHex();
        if (this.size !== undefined) data.size = this.size;
        if (this.shadowSide !== null) data.shadowSide = this.shadowSide;
        if (this.sizeAttenuation !== undefined) data.sizeAttenuation = this.sizeAttenuation;
        if (this.blending !== $d5b85d29c0b78636$export$5b29a26d96ee6af0) data.blending = this.blending;
        if (this.side !== $d5b85d29c0b78636$export$2ede184fc2998901) data.side = this.side;
        if (this.vertexColors === true) data.vertexColors = true;
        if (this.opacity < 1) data.opacity = this.opacity;
        if (this.transparent === true) data.transparent = true;
        if (this.blendSrc !== $d5b85d29c0b78636$export$d5773124e86cf28c) data.blendSrc = this.blendSrc;
        if (this.blendDst !== $d5b85d29c0b78636$export$11d468cc7f19e971) data.blendDst = this.blendDst;
        if (this.blendEquation !== $d5b85d29c0b78636$export$20183a0484ce21a0) data.blendEquation = this.blendEquation;
        if (this.blendSrcAlpha !== null) data.blendSrcAlpha = this.blendSrcAlpha;
        if (this.blendDstAlpha !== null) data.blendDstAlpha = this.blendDstAlpha;
        if (this.blendEquationAlpha !== null) data.blendEquationAlpha = this.blendEquationAlpha;
        if (this.blendColor && this.blendColor.isColor) data.blendColor = this.blendColor.getHex();
        if (this.blendAlpha !== 0) data.blendAlpha = this.blendAlpha;
        if (this.depthFunc !== $d5b85d29c0b78636$export$296f78a0b892f81a) data.depthFunc = this.depthFunc;
        if (this.depthTest === false) data.depthTest = this.depthTest;
        if (this.depthWrite === false) data.depthWrite = this.depthWrite;
        if (this.colorWrite === false) data.colorWrite = this.colorWrite;
        if (this.stencilWriteMask !== 0xff) data.stencilWriteMask = this.stencilWriteMask;
        if (this.stencilFunc !== $d5b85d29c0b78636$export$14cf96713ddd97a8) data.stencilFunc = this.stencilFunc;
        if (this.stencilRef !== 0) data.stencilRef = this.stencilRef;
        if (this.stencilFuncMask !== 0xff) data.stencilFuncMask = this.stencilFuncMask;
        if (this.stencilFail !== $d5b85d29c0b78636$export$9f542ae4b5baca34) data.stencilFail = this.stencilFail;
        if (this.stencilZFail !== $d5b85d29c0b78636$export$9f542ae4b5baca34) data.stencilZFail = this.stencilZFail;
        if (this.stencilZPass !== $d5b85d29c0b78636$export$9f542ae4b5baca34) data.stencilZPass = this.stencilZPass;
        if (this.stencilWrite === true) data.stencilWrite = this.stencilWrite;
        // rotation (SpriteMaterial)
        if (this.rotation !== undefined && this.rotation !== 0) data.rotation = this.rotation;
        if (this.polygonOffset === true) data.polygonOffset = true;
        if (this.polygonOffsetFactor !== 0) data.polygonOffsetFactor = this.polygonOffsetFactor;
        if (this.polygonOffsetUnits !== 0) data.polygonOffsetUnits = this.polygonOffsetUnits;
        if (this.linewidth !== undefined && this.linewidth !== 1) data.linewidth = this.linewidth;
        if (this.dashSize !== undefined) data.dashSize = this.dashSize;
        if (this.gapSize !== undefined) data.gapSize = this.gapSize;
        if (this.scale !== undefined) data.scale = this.scale;
        if (this.dithering === true) data.dithering = true;
        if (this.alphaTest > 0) data.alphaTest = this.alphaTest;
        if (this.alphaHash === true) data.alphaHash = true;
        if (this.alphaToCoverage === true) data.alphaToCoverage = true;
        if (this.premultipliedAlpha === true) data.premultipliedAlpha = true;
        if (this.forceSinglePass === true) data.forceSinglePass = true;
        if (this.wireframe === true) data.wireframe = true;
        if (this.wireframeLinewidth > 1) data.wireframeLinewidth = this.wireframeLinewidth;
        if (this.wireframeLinecap !== 'round') data.wireframeLinecap = this.wireframeLinecap;
        if (this.wireframeLinejoin !== 'round') data.wireframeLinejoin = this.wireframeLinejoin;
        if (this.flatShading === true) data.flatShading = true;
        if (this.visible === false) data.visible = false;
        if (this.toneMapped === false) data.toneMapped = false;
        if (this.fog === false) data.fog = false;
        if (Object.keys(this.userData).length > 0) data.userData = this.userData;
        // TODO: Copied from Object3D.toJSON
        function extractFromCache(cache) {
            const values = [];
            for(const key in cache){
                const data = cache[key];
                delete data.metadata;
                values.push(data);
            }
            return values;
        }
        if (isRootObject) {
            const textures = extractFromCache(meta.textures);
            const images = extractFromCache(meta.images);
            if (textures.length > 0) data.textures = textures;
            if (images.length > 0) data.images = images;
        }
        return data;
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(source) {
        this.name = source.name;
        this.blending = source.blending;
        this.side = source.side;
        this.vertexColors = source.vertexColors;
        this.opacity = source.opacity;
        this.transparent = source.transparent;
        this.blendSrc = source.blendSrc;
        this.blendDst = source.blendDst;
        this.blendEquation = source.blendEquation;
        this.blendSrcAlpha = source.blendSrcAlpha;
        this.blendDstAlpha = source.blendDstAlpha;
        this.blendEquationAlpha = source.blendEquationAlpha;
        this.blendColor.copy(source.blendColor);
        this.blendAlpha = source.blendAlpha;
        this.depthFunc = source.depthFunc;
        this.depthTest = source.depthTest;
        this.depthWrite = source.depthWrite;
        this.stencilWriteMask = source.stencilWriteMask;
        this.stencilFunc = source.stencilFunc;
        this.stencilRef = source.stencilRef;
        this.stencilFuncMask = source.stencilFuncMask;
        this.stencilFail = source.stencilFail;
        this.stencilZFail = source.stencilZFail;
        this.stencilZPass = source.stencilZPass;
        this.stencilWrite = source.stencilWrite;
        const srcPlanes = source.clippingPlanes;
        let dstPlanes = null;
        if (srcPlanes !== null) {
            const n = srcPlanes.length;
            dstPlanes = new Array(n);
            for(let i = 0; i !== n; ++i)dstPlanes[i] = srcPlanes[i].clone();
        }
        this.clippingPlanes = dstPlanes;
        this.clipIntersection = source.clipIntersection;
        this.clipShadows = source.clipShadows;
        this.shadowSide = source.shadowSide;
        this.colorWrite = source.colorWrite;
        this.precision = source.precision;
        this.polygonOffset = source.polygonOffset;
        this.polygonOffsetFactor = source.polygonOffsetFactor;
        this.polygonOffsetUnits = source.polygonOffsetUnits;
        this.dithering = source.dithering;
        this.alphaTest = source.alphaTest;
        this.alphaHash = source.alphaHash;
        this.alphaToCoverage = source.alphaToCoverage;
        this.premultipliedAlpha = source.premultipliedAlpha;
        this.forceSinglePass = source.forceSinglePass;
        this.visible = source.visible;
        this.toneMapped = source.toneMapped;
        this.userData = JSON.parse(JSON.stringify(source.userData));
        return this;
    }
    dispose() {
        this.dispatchEvent({
            type: 'dispose'
        });
    }
    set needsUpdate(value) {
        if (value === true) this.version++;
    }
    onBuild() {
        console.warn('Material: onBuild() has been removed.'); // @deprecated, r166
    }
}
class $d5b85d29c0b78636$export$55cbcc9b622fe1f5 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshBasicMaterial = true;
        this.type = 'MeshBasicMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff); // emissive
        this.map = null;
        this.lightMap = null;
        this.lightMapIntensity = 1.0;
        this.aoMap = null;
        this.aoMapIntensity = 1.0;
        this.specularMap = null;
        this.alphaMap = null;
        this.envMap = null;
        this.envMapRotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        this.combine = $d5b85d29c0b78636$export$e50ac29801f1774d;
        this.reflectivity = 1;
        this.refractionRatio = 0.98;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.map = source.map;
        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;
        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;
        this.specularMap = source.specularMap;
        this.alphaMap = source.alphaMap;
        this.envMap = source.envMap;
        this.envMapRotation.copy(source.envMapRotation);
        this.combine = source.combine;
        this.reflectivity = source.reflectivity;
        this.refractionRatio = source.refractionRatio;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;
        this.fog = source.fog;
        return this;
    }
}
// Fast Half Float Conversions, http://www.fox-toolkit.org/ftp/fasthalffloatconversion.pdf
const $d5b85d29c0b78636$var$_tables = /*@__PURE__*/ $d5b85d29c0b78636$var$_generateTables();
function $d5b85d29c0b78636$var$_generateTables() {
    // float32 to float16 helpers
    const buffer = new ArrayBuffer(4);
    const floatView = new Float32Array(buffer);
    const uint32View = new Uint32Array(buffer);
    const baseTable = new Uint32Array(512);
    const shiftTable = new Uint32Array(512);
    for(let i = 0; i < 256; ++i){
        const e = i - 127;
        // very small number (0, -0)
        if (e < -27) {
            baseTable[i] = 0x0000;
            baseTable[i | 0x100] = 0x8000;
            shiftTable[i] = 24;
            shiftTable[i | 0x100] = 24;
        // small number (denorm)
        } else if (e < -14) {
            baseTable[i] = 0x0400 >> -e - 14;
            baseTable[i | 0x100] = 0x0400 >> -e - 14 | 0x8000;
            shiftTable[i] = -e - 1;
            shiftTable[i | 0x100] = -e - 1;
        // normal number
        } else if (e <= 15) {
            baseTable[i] = e + 15 << 10;
            baseTable[i | 0x100] = e + 15 << 10 | 0x8000;
            shiftTable[i] = 13;
            shiftTable[i | 0x100] = 13;
        // large number (Infinity, -Infinity)
        } else if (e < 128) {
            baseTable[i] = 0x7c00;
            baseTable[i | 0x100] = 0xfc00;
            shiftTable[i] = 24;
            shiftTable[i | 0x100] = 24;
        // stay (NaN, Infinity, -Infinity)
        } else {
            baseTable[i] = 0x7c00;
            baseTable[i | 0x100] = 0xfc00;
            shiftTable[i] = 13;
            shiftTable[i | 0x100] = 13;
        }
    }
    // float16 to float32 helpers
    const mantissaTable = new Uint32Array(2048);
    const exponentTable = new Uint32Array(64);
    const offsetTable = new Uint32Array(64);
    for(let i = 1; i < 1024; ++i){
        let m = i << 13; // zero pad mantissa bits
        let e = 0; // zero exponent
        // normalized
        while((m & 0x00800000) === 0){
            m <<= 1;
            e -= 0x00800000; // decrement exponent
        }
        m &= -8388609; // clear leading 1 bit
        e += 0x38800000; // adjust bias
        mantissaTable[i] = m | e;
    }
    for(let i = 1024; i < 2048; ++i)mantissaTable[i] = 0x38000000 + (i - 1024 << 13);
    for(let i = 1; i < 31; ++i)exponentTable[i] = i << 23;
    exponentTable[31] = 0x47800000;
    exponentTable[32] = 0x80000000;
    for(let i = 33; i < 63; ++i)exponentTable[i] = 0x80000000 + (i - 32 << 23);
    exponentTable[63] = 0xc7800000;
    for(let i = 1; i < 64; ++i)if (i !== 32) offsetTable[i] = 1024;
    return {
        floatView: floatView,
        uint32View: uint32View,
        baseTable: baseTable,
        shiftTable: shiftTable,
        mantissaTable: mantissaTable,
        exponentTable: exponentTable,
        offsetTable: offsetTable
    };
}
// float32 to float16
function $d5b85d29c0b78636$var$toHalfFloat(val) {
    if (Math.abs(val) > 65504) console.warn('THREE.DataUtils.toHalfFloat(): Value out of range.');
    val = $d5b85d29c0b78636$var$clamp(val, -65504, 65504);
    $d5b85d29c0b78636$var$_tables.floatView[0] = val;
    const f = $d5b85d29c0b78636$var$_tables.uint32View[0];
    const e = f >> 23 & 0x1ff;
    return $d5b85d29c0b78636$var$_tables.baseTable[e] + ((f & 0x007fffff) >> $d5b85d29c0b78636$var$_tables.shiftTable[e]);
}
// float16 to float32
function $d5b85d29c0b78636$var$fromHalfFloat(val) {
    const m = val >> 10;
    $d5b85d29c0b78636$var$_tables.uint32View[0] = $d5b85d29c0b78636$var$_tables.mantissaTable[$d5b85d29c0b78636$var$_tables.offsetTable[m] + (val & 0x3ff)] + $d5b85d29c0b78636$var$_tables.exponentTable[m];
    return $d5b85d29c0b78636$var$_tables.floatView[0];
}
const $d5b85d29c0b78636$export$11ce8b759162cc80 = {
    toHalfFloat: $d5b85d29c0b78636$var$toHalfFloat,
    fromHalfFloat: $d5b85d29c0b78636$var$fromHalfFloat
};
const $d5b85d29c0b78636$var$_vector$9 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vector2$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
class $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized = false){
        if (Array.isArray(array)) throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.');
        this.isBufferAttribute = true;
        this.name = '';
        this.array = array;
        this.itemSize = itemSize;
        this.count = array !== undefined ? array.length / itemSize : 0;
        this.normalized = normalized;
        this.usage = $d5b85d29c0b78636$export$763e8360f4d7f77d;
        this.updateRanges = [];
        this.gpuType = $d5b85d29c0b78636$export$f6d331659b644596;
        this.version = 0;
    }
    onUploadCallback() {}
    set needsUpdate(value) {
        if (value === true) this.version++;
    }
    setUsage(value) {
        this.usage = value;
        return this;
    }
    addUpdateRange(start, count) {
        this.updateRanges.push({
            start: start,
            count: count
        });
    }
    clearUpdateRanges() {
        this.updateRanges.length = 0;
    }
    copy(source) {
        this.name = source.name;
        this.array = new source.array.constructor(source.array);
        this.itemSize = source.itemSize;
        this.count = source.count;
        this.normalized = source.normalized;
        this.usage = source.usage;
        this.gpuType = source.gpuType;
        return this;
    }
    copyAt(index1, attribute, index2) {
        index1 *= this.itemSize;
        index2 *= attribute.itemSize;
        for(let i = 0, l = this.itemSize; i < l; i++)this.array[index1 + i] = attribute.array[index2 + i];
        return this;
    }
    copyArray(array) {
        this.array.set(array);
        return this;
    }
    applyMatrix3(m) {
        if (this.itemSize === 2) for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector2$1.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector2$1.applyMatrix3(m);
            this.setXY(i, $d5b85d29c0b78636$var$_vector2$1.x, $d5b85d29c0b78636$var$_vector2$1.y);
        }
        else if (this.itemSize === 3) for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$9.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$9.applyMatrix3(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$9.x, $d5b85d29c0b78636$var$_vector$9.y, $d5b85d29c0b78636$var$_vector$9.z);
        }
        return this;
    }
    applyMatrix4(m) {
        for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$9.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$9.applyMatrix4(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$9.x, $d5b85d29c0b78636$var$_vector$9.y, $d5b85d29c0b78636$var$_vector$9.z);
        }
        return this;
    }
    applyNormalMatrix(m) {
        for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$9.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$9.applyNormalMatrix(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$9.x, $d5b85d29c0b78636$var$_vector$9.y, $d5b85d29c0b78636$var$_vector$9.z);
        }
        return this;
    }
    transformDirection(m) {
        for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$9.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$9.transformDirection(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$9.x, $d5b85d29c0b78636$var$_vector$9.y, $d5b85d29c0b78636$var$_vector$9.z);
        }
        return this;
    }
    set(value, offset = 0) {
        // Matching BufferAttribute constructor, do not normalize the array.
        this.array.set(value, offset);
        return this;
    }
    getComponent(index, component) {
        let value = this.array[index * this.itemSize + component];
        if (this.normalized) value = $d5b85d29c0b78636$var$denormalize(value, this.array);
        return value;
    }
    setComponent(index, component, value) {
        if (this.normalized) value = $d5b85d29c0b78636$var$normalize(value, this.array);
        this.array[index * this.itemSize + component] = value;
        return this;
    }
    getX(index) {
        let x = this.array[index * this.itemSize];
        if (this.normalized) x = $d5b85d29c0b78636$var$denormalize(x, this.array);
        return x;
    }
    setX(index, x) {
        if (this.normalized) x = $d5b85d29c0b78636$var$normalize(x, this.array);
        this.array[index * this.itemSize] = x;
        return this;
    }
    getY(index) {
        let y = this.array[index * this.itemSize + 1];
        if (this.normalized) y = $d5b85d29c0b78636$var$denormalize(y, this.array);
        return y;
    }
    setY(index, y) {
        if (this.normalized) y = $d5b85d29c0b78636$var$normalize(y, this.array);
        this.array[index * this.itemSize + 1] = y;
        return this;
    }
    getZ(index) {
        let z = this.array[index * this.itemSize + 2];
        if (this.normalized) z = $d5b85d29c0b78636$var$denormalize(z, this.array);
        return z;
    }
    setZ(index, z) {
        if (this.normalized) z = $d5b85d29c0b78636$var$normalize(z, this.array);
        this.array[index * this.itemSize + 2] = z;
        return this;
    }
    getW(index) {
        let w = this.array[index * this.itemSize + 3];
        if (this.normalized) w = $d5b85d29c0b78636$var$denormalize(w, this.array);
        return w;
    }
    setW(index, w) {
        if (this.normalized) w = $d5b85d29c0b78636$var$normalize(w, this.array);
        this.array[index * this.itemSize + 3] = w;
        return this;
    }
    setXY(index, x, y) {
        index *= this.itemSize;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
        }
        this.array[index + 0] = x;
        this.array[index + 1] = y;
        return this;
    }
    setXYZ(index, x, y, z) {
        index *= this.itemSize;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
            z = $d5b85d29c0b78636$var$normalize(z, this.array);
        }
        this.array[index + 0] = x;
        this.array[index + 1] = y;
        this.array[index + 2] = z;
        return this;
    }
    setXYZW(index, x, y, z, w) {
        index *= this.itemSize;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
            z = $d5b85d29c0b78636$var$normalize(z, this.array);
            w = $d5b85d29c0b78636$var$normalize(w, this.array);
        }
        this.array[index + 0] = x;
        this.array[index + 1] = y;
        this.array[index + 2] = z;
        this.array[index + 3] = w;
        return this;
    }
    onUpload(callback) {
        this.onUploadCallback = callback;
        return this;
    }
    clone() {
        return new this.constructor(this.array, this.itemSize).copy(this);
    }
    toJSON() {
        const data = {
            itemSize: this.itemSize,
            type: this.array.constructor.name,
            array: Array.from(this.array),
            normalized: this.normalized
        };
        if (this.name !== '') data.name = this.name;
        if (this.usage !== $d5b85d29c0b78636$export$763e8360f4d7f77d) data.usage = this.usage;
        return data;
    }
}
//
class $d5b85d29c0b78636$export$f9ff2d6a20248cbf extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Int8Array(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$cacc90cf35d11cdd extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Uint8Array(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$baaa85a1a812c157 extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Uint8ClampedArray(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$2b755a102ccdcefe extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Int16Array(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$640a853f68025f2e extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Uint16Array(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$46b369aed2968a0a extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Int32Array(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$7eb8c9fa25cd5bd6 extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Uint32Array(array), itemSize, normalized);
    }
}
class $d5b85d29c0b78636$export$dbd3698c64958d69 extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Uint16Array(array), itemSize, normalized);
        this.isFloat16BufferAttribute = true;
    }
    getX(index) {
        let x = $d5b85d29c0b78636$var$fromHalfFloat(this.array[index * this.itemSize]);
        if (this.normalized) x = $d5b85d29c0b78636$var$denormalize(x, this.array);
        return x;
    }
    setX(index, x) {
        if (this.normalized) x = $d5b85d29c0b78636$var$normalize(x, this.array);
        this.array[index * this.itemSize] = $d5b85d29c0b78636$var$toHalfFloat(x);
        return this;
    }
    getY(index) {
        let y = $d5b85d29c0b78636$var$fromHalfFloat(this.array[index * this.itemSize + 1]);
        if (this.normalized) y = $d5b85d29c0b78636$var$denormalize(y, this.array);
        return y;
    }
    setY(index, y) {
        if (this.normalized) y = $d5b85d29c0b78636$var$normalize(y, this.array);
        this.array[index * this.itemSize + 1] = $d5b85d29c0b78636$var$toHalfFloat(y);
        return this;
    }
    getZ(index) {
        let z = $d5b85d29c0b78636$var$fromHalfFloat(this.array[index * this.itemSize + 2]);
        if (this.normalized) z = $d5b85d29c0b78636$var$denormalize(z, this.array);
        return z;
    }
    setZ(index, z) {
        if (this.normalized) z = $d5b85d29c0b78636$var$normalize(z, this.array);
        this.array[index * this.itemSize + 2] = $d5b85d29c0b78636$var$toHalfFloat(z);
        return this;
    }
    getW(index) {
        let w = $d5b85d29c0b78636$var$fromHalfFloat(this.array[index * this.itemSize + 3]);
        if (this.normalized) w = $d5b85d29c0b78636$var$denormalize(w, this.array);
        return w;
    }
    setW(index, w) {
        if (this.normalized) w = $d5b85d29c0b78636$var$normalize(w, this.array);
        this.array[index * this.itemSize + 3] = $d5b85d29c0b78636$var$toHalfFloat(w);
        return this;
    }
    setXY(index, x, y) {
        index *= this.itemSize;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
        }
        this.array[index + 0] = $d5b85d29c0b78636$var$toHalfFloat(x);
        this.array[index + 1] = $d5b85d29c0b78636$var$toHalfFloat(y);
        return this;
    }
    setXYZ(index, x, y, z) {
        index *= this.itemSize;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
            z = $d5b85d29c0b78636$var$normalize(z, this.array);
        }
        this.array[index + 0] = $d5b85d29c0b78636$var$toHalfFloat(x);
        this.array[index + 1] = $d5b85d29c0b78636$var$toHalfFloat(y);
        this.array[index + 2] = $d5b85d29c0b78636$var$toHalfFloat(z);
        return this;
    }
    setXYZW(index, x, y, z, w) {
        index *= this.itemSize;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
            z = $d5b85d29c0b78636$var$normalize(z, this.array);
            w = $d5b85d29c0b78636$var$normalize(w, this.array);
        }
        this.array[index + 0] = $d5b85d29c0b78636$var$toHalfFloat(x);
        this.array[index + 1] = $d5b85d29c0b78636$var$toHalfFloat(y);
        this.array[index + 2] = $d5b85d29c0b78636$var$toHalfFloat(z);
        this.array[index + 3] = $d5b85d29c0b78636$var$toHalfFloat(w);
        return this;
    }
}
class $d5b85d29c0b78636$export$cbe7a62641830ebd extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized){
        super(new Float32Array(array), itemSize, normalized);
    }
}
let $d5b85d29c0b78636$var$_id$1 = 0;
const $d5b85d29c0b78636$var$_m1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_obj = /*@__PURE__*/ new $d5b85d29c0b78636$export$e4dd07dff30cc924();
const $d5b85d29c0b78636$var$_offset = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_box$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
const $d5b85d29c0b78636$var$_boxMorphTargets = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
const $d5b85d29c0b78636$var$_vector$8 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$b7be63a67df8959 extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(){
        super();
        this.isBufferGeometry = true;
        Object.defineProperty(this, 'id', {
            value: $d5b85d29c0b78636$var$_id$1++
        });
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.name = '';
        this.type = 'BufferGeometry';
        this.index = null;
        this.indirect = null;
        this.attributes = {};
        this.morphAttributes = {};
        this.morphTargetsRelative = false;
        this.groups = [];
        this.boundingBox = null;
        this.boundingSphere = null;
        this.drawRange = {
            start: 0,
            count: Infinity
        };
        this.userData = {};
    }
    getIndex() {
        return this.index;
    }
    setIndex(index) {
        if (Array.isArray(index)) this.index = new ($d5b85d29c0b78636$export$bc6f937da07eae17(index) ? $d5b85d29c0b78636$export$7eb8c9fa25cd5bd6 : $d5b85d29c0b78636$export$640a853f68025f2e)(index, 1);
        else this.index = index;
        return this;
    }
    setIndirect(indirect) {
        this.indirect = indirect;
        return this;
    }
    getIndirect() {
        return this.indirect;
    }
    getAttribute(name) {
        return this.attributes[name];
    }
    setAttribute(name, attribute) {
        this.attributes[name] = attribute;
        return this;
    }
    deleteAttribute(name) {
        delete this.attributes[name];
        return this;
    }
    hasAttribute(name) {
        return this.attributes[name] !== undefined;
    }
    addGroup(start, count, materialIndex = 0) {
        this.groups.push({
            start: start,
            count: count,
            materialIndex: materialIndex
        });
    }
    clearGroups() {
        this.groups = [];
    }
    setDrawRange(start, count) {
        this.drawRange.start = start;
        this.drawRange.count = count;
    }
    applyMatrix4(matrix) {
        const position = this.attributes.position;
        if (position !== undefined) {
            position.applyMatrix4(matrix);
            position.needsUpdate = true;
        }
        const normal = this.attributes.normal;
        if (normal !== undefined) {
            const normalMatrix = new $d5b85d29c0b78636$export$8ff26dafa08918().getNormalMatrix(matrix);
            normal.applyNormalMatrix(normalMatrix);
            normal.needsUpdate = true;
        }
        const tangent = this.attributes.tangent;
        if (tangent !== undefined) {
            tangent.transformDirection(matrix);
            tangent.needsUpdate = true;
        }
        if (this.boundingBox !== null) this.computeBoundingBox();
        if (this.boundingSphere !== null) this.computeBoundingSphere();
        return this;
    }
    applyQuaternion(q) {
        $d5b85d29c0b78636$var$_m1.makeRotationFromQuaternion(q);
        this.applyMatrix4($d5b85d29c0b78636$var$_m1);
        return this;
    }
    rotateX(angle) {
        // rotate geometry around world x-axis
        $d5b85d29c0b78636$var$_m1.makeRotationX(angle);
        this.applyMatrix4($d5b85d29c0b78636$var$_m1);
        return this;
    }
    rotateY(angle) {
        // rotate geometry around world y-axis
        $d5b85d29c0b78636$var$_m1.makeRotationY(angle);
        this.applyMatrix4($d5b85d29c0b78636$var$_m1);
        return this;
    }
    rotateZ(angle) {
        // rotate geometry around world z-axis
        $d5b85d29c0b78636$var$_m1.makeRotationZ(angle);
        this.applyMatrix4($d5b85d29c0b78636$var$_m1);
        return this;
    }
    translate(x, y, z) {
        // translate geometry
        $d5b85d29c0b78636$var$_m1.makeTranslation(x, y, z);
        this.applyMatrix4($d5b85d29c0b78636$var$_m1);
        return this;
    }
    scale(x, y, z) {
        // scale geometry
        $d5b85d29c0b78636$var$_m1.makeScale(x, y, z);
        this.applyMatrix4($d5b85d29c0b78636$var$_m1);
        return this;
    }
    lookAt(vector) {
        $d5b85d29c0b78636$var$_obj.lookAt(vector);
        $d5b85d29c0b78636$var$_obj.updateMatrix();
        this.applyMatrix4($d5b85d29c0b78636$var$_obj.matrix);
        return this;
    }
    center() {
        this.computeBoundingBox();
        this.boundingBox.getCenter($d5b85d29c0b78636$var$_offset).negate();
        this.translate($d5b85d29c0b78636$var$_offset.x, $d5b85d29c0b78636$var$_offset.y, $d5b85d29c0b78636$var$_offset.z);
        return this;
    }
    setFromPoints(points) {
        const positionAttribute = this.getAttribute('position');
        if (positionAttribute === undefined) {
            const position = [];
            for(let i = 0, l = points.length; i < l; i++){
                const point = points[i];
                position.push(point.x, point.y, point.z || 0);
            }
            this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(position, 3));
        } else {
            const l = Math.min(points.length, positionAttribute.count); // make sure data do not exceed buffer size
            for(let i = 0; i < l; i++){
                const point = points[i];
                positionAttribute.setXYZ(i, point.x, point.y, point.z || 0);
            }
            if (points.length > positionAttribute.count) console.warn('THREE.BufferGeometry: Buffer size too small for points data. Use .dispose() and create a new geometry.');
            positionAttribute.needsUpdate = true;
        }
        return this;
    }
    computeBoundingBox() {
        if (this.boundingBox === null) this.boundingBox = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
        const position = this.attributes.position;
        const morphAttributesPosition = this.morphAttributes.position;
        if (position && position.isGLBufferAttribute) {
            console.error('THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box.', this);
            this.boundingBox.set(new $d5b85d29c0b78636$export$64b5c384219d3699(-Infinity, -Infinity, -Infinity), new $d5b85d29c0b78636$export$64b5c384219d3699(Infinity, Infinity, Infinity));
            return;
        }
        if (position !== undefined) {
            this.boundingBox.setFromBufferAttribute(position);
            // process morph attributes if present
            if (morphAttributesPosition) for(let i = 0, il = morphAttributesPosition.length; i < il; i++){
                const morphAttribute = morphAttributesPosition[i];
                $d5b85d29c0b78636$var$_box$2.setFromBufferAttribute(morphAttribute);
                if (this.morphTargetsRelative) {
                    $d5b85d29c0b78636$var$_vector$8.addVectors(this.boundingBox.min, $d5b85d29c0b78636$var$_box$2.min);
                    this.boundingBox.expandByPoint($d5b85d29c0b78636$var$_vector$8);
                    $d5b85d29c0b78636$var$_vector$8.addVectors(this.boundingBox.max, $d5b85d29c0b78636$var$_box$2.max);
                    this.boundingBox.expandByPoint($d5b85d29c0b78636$var$_vector$8);
                } else {
                    this.boundingBox.expandByPoint($d5b85d29c0b78636$var$_box$2.min);
                    this.boundingBox.expandByPoint($d5b85d29c0b78636$var$_box$2.max);
                }
            }
        } else this.boundingBox.makeEmpty();
        if (isNaN(this.boundingBox.min.x) || isNaN(this.boundingBox.min.y) || isNaN(this.boundingBox.min.z)) console.error('THREE.BufferGeometry.computeBoundingBox(): Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this);
    }
    computeBoundingSphere() {
        if (this.boundingSphere === null) this.boundingSphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
        const position = this.attributes.position;
        const morphAttributesPosition = this.morphAttributes.position;
        if (position && position.isGLBufferAttribute) {
            console.error('THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere.', this);
            this.boundingSphere.set(new $d5b85d29c0b78636$export$64b5c384219d3699(), Infinity);
            return;
        }
        if (position) {
            // first, find the center of the bounding sphere
            const center = this.boundingSphere.center;
            $d5b85d29c0b78636$var$_box$2.setFromBufferAttribute(position);
            // process morph attributes if present
            if (morphAttributesPosition) for(let i = 0, il = morphAttributesPosition.length; i < il; i++){
                const morphAttribute = morphAttributesPosition[i];
                $d5b85d29c0b78636$var$_boxMorphTargets.setFromBufferAttribute(morphAttribute);
                if (this.morphTargetsRelative) {
                    $d5b85d29c0b78636$var$_vector$8.addVectors($d5b85d29c0b78636$var$_box$2.min, $d5b85d29c0b78636$var$_boxMorphTargets.min);
                    $d5b85d29c0b78636$var$_box$2.expandByPoint($d5b85d29c0b78636$var$_vector$8);
                    $d5b85d29c0b78636$var$_vector$8.addVectors($d5b85d29c0b78636$var$_box$2.max, $d5b85d29c0b78636$var$_boxMorphTargets.max);
                    $d5b85d29c0b78636$var$_box$2.expandByPoint($d5b85d29c0b78636$var$_vector$8);
                } else {
                    $d5b85d29c0b78636$var$_box$2.expandByPoint($d5b85d29c0b78636$var$_boxMorphTargets.min);
                    $d5b85d29c0b78636$var$_box$2.expandByPoint($d5b85d29c0b78636$var$_boxMorphTargets.max);
                }
            }
            $d5b85d29c0b78636$var$_box$2.getCenter(center);
            // second, try to find a boundingSphere with a radius smaller than the
            // boundingSphere of the boundingBox: sqrt(3) smaller in the best case
            let maxRadiusSq = 0;
            for(let i = 0, il = position.count; i < il; i++){
                $d5b85d29c0b78636$var$_vector$8.fromBufferAttribute(position, i);
                maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared($d5b85d29c0b78636$var$_vector$8));
            }
            // process morph attributes if present
            if (morphAttributesPosition) for(let i = 0, il = morphAttributesPosition.length; i < il; i++){
                const morphAttribute = morphAttributesPosition[i];
                const morphTargetsRelative = this.morphTargetsRelative;
                for(let j = 0, jl = morphAttribute.count; j < jl; j++){
                    $d5b85d29c0b78636$var$_vector$8.fromBufferAttribute(morphAttribute, j);
                    if (morphTargetsRelative) {
                        $d5b85d29c0b78636$var$_offset.fromBufferAttribute(position, j);
                        $d5b85d29c0b78636$var$_vector$8.add($d5b85d29c0b78636$var$_offset);
                    }
                    maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared($d5b85d29c0b78636$var$_vector$8));
                }
            }
            this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
            if (isNaN(this.boundingSphere.radius)) console.error('THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this);
        }
    }
    computeTangents() {
        const index = this.index;
        const attributes = this.attributes;
        // based on http://www.terathon.com/code/tangent.html
        // (per vertex tangents)
        if (index === null || attributes.position === undefined || attributes.normal === undefined || attributes.uv === undefined) {
            console.error('THREE.BufferGeometry: .computeTangents() failed. Missing required attributes (index, position, normal or uv)');
            return;
        }
        const positionAttribute = attributes.position;
        const normalAttribute = attributes.normal;
        const uvAttribute = attributes.uv;
        if (this.hasAttribute('tangent') === false) this.setAttribute('tangent', new $d5b85d29c0b78636$export$8dea267bd6bde117(new Float32Array(4 * positionAttribute.count), 4));
        const tangentAttribute = this.getAttribute('tangent');
        const tan1 = [], tan2 = [];
        for(let i = 0; i < positionAttribute.count; i++){
            tan1[i] = new $d5b85d29c0b78636$export$64b5c384219d3699();
            tan2[i] = new $d5b85d29c0b78636$export$64b5c384219d3699();
        }
        const vA = new $d5b85d29c0b78636$export$64b5c384219d3699(), vB = new $d5b85d29c0b78636$export$64b5c384219d3699(), vC = new $d5b85d29c0b78636$export$64b5c384219d3699(), uvA = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), uvB = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), uvC = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), sdir = new $d5b85d29c0b78636$export$64b5c384219d3699(), tdir = new $d5b85d29c0b78636$export$64b5c384219d3699();
        function handleTriangle(a, b, c) {
            vA.fromBufferAttribute(positionAttribute, a);
            vB.fromBufferAttribute(positionAttribute, b);
            vC.fromBufferAttribute(positionAttribute, c);
            uvA.fromBufferAttribute(uvAttribute, a);
            uvB.fromBufferAttribute(uvAttribute, b);
            uvC.fromBufferAttribute(uvAttribute, c);
            vB.sub(vA);
            vC.sub(vA);
            uvB.sub(uvA);
            uvC.sub(uvA);
            const r = 1.0 / (uvB.x * uvC.y - uvC.x * uvB.y);
            // silently ignore degenerate uv triangles having coincident or colinear vertices
            if (!isFinite(r)) return;
            sdir.copy(vB).multiplyScalar(uvC.y).addScaledVector(vC, -uvB.y).multiplyScalar(r);
            tdir.copy(vC).multiplyScalar(uvB.x).addScaledVector(vB, -uvC.x).multiplyScalar(r);
            tan1[a].add(sdir);
            tan1[b].add(sdir);
            tan1[c].add(sdir);
            tan2[a].add(tdir);
            tan2[b].add(tdir);
            tan2[c].add(tdir);
        }
        let groups = this.groups;
        if (groups.length === 0) groups = [
            {
                start: 0,
                count: index.count
            }
        ];
        for(let i = 0, il = groups.length; i < il; ++i){
            const group = groups[i];
            const start = group.start;
            const count = group.count;
            for(let j = start, jl = start + count; j < jl; j += 3)handleTriangle(index.getX(j + 0), index.getX(j + 1), index.getX(j + 2));
        }
        const tmp = new $d5b85d29c0b78636$export$64b5c384219d3699(), tmp2 = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const n = new $d5b85d29c0b78636$export$64b5c384219d3699(), n2 = new $d5b85d29c0b78636$export$64b5c384219d3699();
        function handleVertex(v) {
            n.fromBufferAttribute(normalAttribute, v);
            n2.copy(n);
            const t = tan1[v];
            // Gram-Schmidt orthogonalize
            tmp.copy(t);
            tmp.sub(n.multiplyScalar(n.dot(t))).normalize();
            // Calculate handedness
            tmp2.crossVectors(n2, t);
            const test = tmp2.dot(tan2[v]);
            const w = test < 0.0 ? -1 : 1.0;
            tangentAttribute.setXYZW(v, tmp.x, tmp.y, tmp.z, w);
        }
        for(let i = 0, il = groups.length; i < il; ++i){
            const group = groups[i];
            const start = group.start;
            const count = group.count;
            for(let j = start, jl = start + count; j < jl; j += 3){
                handleVertex(index.getX(j + 0));
                handleVertex(index.getX(j + 1));
                handleVertex(index.getX(j + 2));
            }
        }
    }
    computeVertexNormals() {
        const index = this.index;
        const positionAttribute = this.getAttribute('position');
        if (positionAttribute !== undefined) {
            let normalAttribute = this.getAttribute('normal');
            if (normalAttribute === undefined) {
                normalAttribute = new $d5b85d29c0b78636$export$8dea267bd6bde117(new Float32Array(positionAttribute.count * 3), 3);
                this.setAttribute('normal', normalAttribute);
            } else // reset existing normals to zero
            for(let i = 0, il = normalAttribute.count; i < il; i++)normalAttribute.setXYZ(i, 0, 0, 0);
            const pA = new $d5b85d29c0b78636$export$64b5c384219d3699(), pB = new $d5b85d29c0b78636$export$64b5c384219d3699(), pC = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const nA = new $d5b85d29c0b78636$export$64b5c384219d3699(), nB = new $d5b85d29c0b78636$export$64b5c384219d3699(), nC = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const cb = new $d5b85d29c0b78636$export$64b5c384219d3699(), ab = new $d5b85d29c0b78636$export$64b5c384219d3699();
            // indexed elements
            if (index) for(let i = 0, il = index.count; i < il; i += 3){
                const vA = index.getX(i + 0);
                const vB = index.getX(i + 1);
                const vC = index.getX(i + 2);
                pA.fromBufferAttribute(positionAttribute, vA);
                pB.fromBufferAttribute(positionAttribute, vB);
                pC.fromBufferAttribute(positionAttribute, vC);
                cb.subVectors(pC, pB);
                ab.subVectors(pA, pB);
                cb.cross(ab);
                nA.fromBufferAttribute(normalAttribute, vA);
                nB.fromBufferAttribute(normalAttribute, vB);
                nC.fromBufferAttribute(normalAttribute, vC);
                nA.add(cb);
                nB.add(cb);
                nC.add(cb);
                normalAttribute.setXYZ(vA, nA.x, nA.y, nA.z);
                normalAttribute.setXYZ(vB, nB.x, nB.y, nB.z);
                normalAttribute.setXYZ(vC, nC.x, nC.y, nC.z);
            }
            else // non-indexed elements (unconnected triangle soup)
            for(let i = 0, il = positionAttribute.count; i < il; i += 3){
                pA.fromBufferAttribute(positionAttribute, i + 0);
                pB.fromBufferAttribute(positionAttribute, i + 1);
                pC.fromBufferAttribute(positionAttribute, i + 2);
                cb.subVectors(pC, pB);
                ab.subVectors(pA, pB);
                cb.cross(ab);
                normalAttribute.setXYZ(i + 0, cb.x, cb.y, cb.z);
                normalAttribute.setXYZ(i + 1, cb.x, cb.y, cb.z);
                normalAttribute.setXYZ(i + 2, cb.x, cb.y, cb.z);
            }
            this.normalizeNormals();
            normalAttribute.needsUpdate = true;
        }
    }
    normalizeNormals() {
        const normals = this.attributes.normal;
        for(let i = 0, il = normals.count; i < il; i++){
            $d5b85d29c0b78636$var$_vector$8.fromBufferAttribute(normals, i);
            $d5b85d29c0b78636$var$_vector$8.normalize();
            normals.setXYZ(i, $d5b85d29c0b78636$var$_vector$8.x, $d5b85d29c0b78636$var$_vector$8.y, $d5b85d29c0b78636$var$_vector$8.z);
        }
    }
    toNonIndexed() {
        function convertBufferAttribute(attribute, indices) {
            const array = attribute.array;
            const itemSize = attribute.itemSize;
            const normalized = attribute.normalized;
            const array2 = new array.constructor(indices.length * itemSize);
            let index = 0, index2 = 0;
            for(let i = 0, l = indices.length; i < l; i++){
                if (attribute.isInterleavedBufferAttribute) index = indices[i] * attribute.data.stride + attribute.offset;
                else index = indices[i] * itemSize;
                for(let j = 0; j < itemSize; j++)array2[index2++] = array[index++];
            }
            return new $d5b85d29c0b78636$export$8dea267bd6bde117(array2, itemSize, normalized);
        }
        //
        if (this.index === null) {
            console.warn('THREE.BufferGeometry.toNonIndexed(): BufferGeometry is already non-indexed.');
            return this;
        }
        const geometry2 = new $d5b85d29c0b78636$export$b7be63a67df8959();
        const indices = this.index.array;
        const attributes = this.attributes;
        // attributes
        for(const name in attributes){
            const attribute = attributes[name];
            const newAttribute = convertBufferAttribute(attribute, indices);
            geometry2.setAttribute(name, newAttribute);
        }
        // morph attributes
        const morphAttributes = this.morphAttributes;
        for(const name in morphAttributes){
            const morphArray = [];
            const morphAttribute = morphAttributes[name]; // morphAttribute: array of Float32BufferAttributes
            for(let i = 0, il = morphAttribute.length; i < il; i++){
                const attribute = morphAttribute[i];
                const newAttribute = convertBufferAttribute(attribute, indices);
                morphArray.push(newAttribute);
            }
            geometry2.morphAttributes[name] = morphArray;
        }
        geometry2.morphTargetsRelative = this.morphTargetsRelative;
        // groups
        const groups = this.groups;
        for(let i = 0, l = groups.length; i < l; i++){
            const group = groups[i];
            geometry2.addGroup(group.start, group.count, group.materialIndex);
        }
        return geometry2;
    }
    toJSON() {
        const data = {
            metadata: {
                version: 4.6,
                type: 'BufferGeometry',
                generator: 'BufferGeometry.toJSON'
            }
        };
        // standard BufferGeometry serialization
        data.uuid = this.uuid;
        data.type = this.type;
        if (this.name !== '') data.name = this.name;
        if (Object.keys(this.userData).length > 0) data.userData = this.userData;
        if (this.parameters !== undefined) {
            const parameters = this.parameters;
            for(const key in parameters)if (parameters[key] !== undefined) data[key] = parameters[key];
            return data;
        }
        // for simplicity the code assumes attributes are not shared across geometries, see #15811
        data.data = {
            attributes: {}
        };
        const index = this.index;
        if (index !== null) data.data.index = {
            type: index.array.constructor.name,
            array: Array.prototype.slice.call(index.array)
        };
        const attributes = this.attributes;
        for(const key in attributes){
            const attribute = attributes[key];
            data.data.attributes[key] = attribute.toJSON(data.data);
        }
        const morphAttributes = {};
        let hasMorphAttributes = false;
        for(const key in this.morphAttributes){
            const attributeArray = this.morphAttributes[key];
            const array = [];
            for(let i = 0, il = attributeArray.length; i < il; i++){
                const attribute = attributeArray[i];
                array.push(attribute.toJSON(data.data));
            }
            if (array.length > 0) {
                morphAttributes[key] = array;
                hasMorphAttributes = true;
            }
        }
        if (hasMorphAttributes) {
            data.data.morphAttributes = morphAttributes;
            data.data.morphTargetsRelative = this.morphTargetsRelative;
        }
        const groups = this.groups;
        if (groups.length > 0) data.data.groups = JSON.parse(JSON.stringify(groups));
        const boundingSphere = this.boundingSphere;
        if (boundingSphere !== null) data.data.boundingSphere = {
            center: boundingSphere.center.toArray(),
            radius: boundingSphere.radius
        };
        return data;
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(source) {
        // reset
        this.index = null;
        this.attributes = {};
        this.morphAttributes = {};
        this.groups = [];
        this.boundingBox = null;
        this.boundingSphere = null;
        // used for storing cloned, shared data
        const data = {};
        // name
        this.name = source.name;
        // index
        const index = source.index;
        if (index !== null) this.setIndex(index.clone(data));
        // attributes
        const attributes = source.attributes;
        for(const name in attributes){
            const attribute = attributes[name];
            this.setAttribute(name, attribute.clone(data));
        }
        // morph attributes
        const morphAttributes = source.morphAttributes;
        for(const name in morphAttributes){
            const array = [];
            const morphAttribute = morphAttributes[name]; // morphAttribute: array of Float32BufferAttributes
            for(let i = 0, l = morphAttribute.length; i < l; i++)array.push(morphAttribute[i].clone(data));
            this.morphAttributes[name] = array;
        }
        this.morphTargetsRelative = source.morphTargetsRelative;
        // groups
        const groups = source.groups;
        for(let i = 0, l = groups.length; i < l; i++){
            const group = groups[i];
            this.addGroup(group.start, group.count, group.materialIndex);
        }
        // bounding box
        const boundingBox = source.boundingBox;
        if (boundingBox !== null) this.boundingBox = boundingBox.clone();
        // bounding sphere
        const boundingSphere = source.boundingSphere;
        if (boundingSphere !== null) this.boundingSphere = boundingSphere.clone();
        // draw range
        this.drawRange.start = source.drawRange.start;
        this.drawRange.count = source.drawRange.count;
        // user data
        this.userData = source.userData;
        return this;
    }
    dispose() {
        this.dispatchEvent({
            type: 'dispose'
        });
    }
}
const $d5b85d29c0b78636$var$_inverseMatrix$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_ray$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$a186db52eed6d40e();
const $d5b85d29c0b78636$var$_sphere$6 = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
const $d5b85d29c0b78636$var$_sphereHitAt = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vA$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vB$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vC$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_tempA = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_morphA = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_intersectionPoint = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_intersectionPointWorld = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$e176487c05830cc5 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(geometry = new $d5b85d29c0b78636$export$b7be63a67df8959(), material = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5()){
        super();
        this.isMesh = true;
        this.type = 'Mesh';
        this.geometry = geometry;
        this.material = material;
        this.updateMorphTargets();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        if (source.morphTargetInfluences !== undefined) this.morphTargetInfluences = source.morphTargetInfluences.slice();
        if (source.morphTargetDictionary !== undefined) this.morphTargetDictionary = Object.assign({}, source.morphTargetDictionary);
        this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
        this.geometry = source.geometry;
        return this;
    }
    updateMorphTargets() {
        const geometry = this.geometry;
        const morphAttributes = geometry.morphAttributes;
        const keys = Object.keys(morphAttributes);
        if (keys.length > 0) {
            const morphAttribute = morphAttributes[keys[0]];
            if (morphAttribute !== undefined) {
                this.morphTargetInfluences = [];
                this.morphTargetDictionary = {};
                for(let m = 0, ml = morphAttribute.length; m < ml; m++){
                    const name = morphAttribute[m].name || String(m);
                    this.morphTargetInfluences.push(0);
                    this.morphTargetDictionary[name] = m;
                }
            }
        }
    }
    getVertexPosition(index, target) {
        const geometry = this.geometry;
        const position = geometry.attributes.position;
        const morphPosition = geometry.morphAttributes.position;
        const morphTargetsRelative = geometry.morphTargetsRelative;
        target.fromBufferAttribute(position, index);
        const morphInfluences = this.morphTargetInfluences;
        if (morphPosition && morphInfluences) {
            $d5b85d29c0b78636$var$_morphA.set(0, 0, 0);
            for(let i = 0, il = morphPosition.length; i < il; i++){
                const influence = morphInfluences[i];
                const morphAttribute = morphPosition[i];
                if (influence === 0) continue;
                $d5b85d29c0b78636$var$_tempA.fromBufferAttribute(morphAttribute, index);
                if (morphTargetsRelative) $d5b85d29c0b78636$var$_morphA.addScaledVector($d5b85d29c0b78636$var$_tempA, influence);
                else $d5b85d29c0b78636$var$_morphA.addScaledVector($d5b85d29c0b78636$var$_tempA.sub(target), influence);
            }
            target.add($d5b85d29c0b78636$var$_morphA);
        }
        return target;
    }
    raycast(raycaster, intersects) {
        const geometry = this.geometry;
        const material = this.material;
        const matrixWorld = this.matrixWorld;
        if (material === undefined) return;
        // test with bounding sphere in world space
        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
        $d5b85d29c0b78636$var$_sphere$6.copy(geometry.boundingSphere);
        $d5b85d29c0b78636$var$_sphere$6.applyMatrix4(matrixWorld);
        // check distance from ray origin to bounding sphere
        $d5b85d29c0b78636$var$_ray$3.copy(raycaster.ray).recast(raycaster.near);
        if ($d5b85d29c0b78636$var$_sphere$6.containsPoint($d5b85d29c0b78636$var$_ray$3.origin) === false) {
            if ($d5b85d29c0b78636$var$_ray$3.intersectSphere($d5b85d29c0b78636$var$_sphere$6, $d5b85d29c0b78636$var$_sphereHitAt) === null) return;
            if ($d5b85d29c0b78636$var$_ray$3.origin.distanceToSquared($d5b85d29c0b78636$var$_sphereHitAt) > (raycaster.far - raycaster.near) ** 2) return;
        }
        // convert ray to local space of mesh
        $d5b85d29c0b78636$var$_inverseMatrix$3.copy(matrixWorld).invert();
        $d5b85d29c0b78636$var$_ray$3.copy(raycaster.ray).applyMatrix4($d5b85d29c0b78636$var$_inverseMatrix$3);
        // test with bounding box in local space
        if (geometry.boundingBox !== null) {
            if ($d5b85d29c0b78636$var$_ray$3.intersectsBox(geometry.boundingBox) === false) return;
        }
        // test for intersections with geometry
        this._computeIntersections(raycaster, intersects, $d5b85d29c0b78636$var$_ray$3);
    }
    _computeIntersections(raycaster, intersects, rayLocalSpace) {
        let intersection;
        const geometry = this.geometry;
        const material = this.material;
        const index = geometry.index;
        const position = geometry.attributes.position;
        const uv = geometry.attributes.uv;
        const uv1 = geometry.attributes.uv1;
        const normal = geometry.attributes.normal;
        const groups = geometry.groups;
        const drawRange = geometry.drawRange;
        if (index !== null) {
            // indexed buffer geometry
            if (Array.isArray(material)) for(let i = 0, il = groups.length; i < il; i++){
                const group = groups[i];
                const groupMaterial = material[group.materialIndex];
                const start = Math.max(group.start, drawRange.start);
                const end = Math.min(index.count, Math.min(group.start + group.count, drawRange.start + drawRange.count));
                for(let j = start, jl = end; j < jl; j += 3){
                    const a = index.getX(j);
                    const b = index.getX(j + 1);
                    const c = index.getX(j + 2);
                    intersection = $d5b85d29c0b78636$var$checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
                    if (intersection) {
                        intersection.faceIndex = Math.floor(j / 3); // triangle number in indexed buffer semantics
                        intersection.face.materialIndex = group.materialIndex;
                        intersects.push(intersection);
                    }
                }
            }
            else {
                const start = Math.max(0, drawRange.start);
                const end = Math.min(index.count, drawRange.start + drawRange.count);
                for(let i = start, il = end; i < il; i += 3){
                    const a = index.getX(i);
                    const b = index.getX(i + 1);
                    const c = index.getX(i + 2);
                    intersection = $d5b85d29c0b78636$var$checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
                    if (intersection) {
                        intersection.faceIndex = Math.floor(i / 3); // triangle number in indexed buffer semantics
                        intersects.push(intersection);
                    }
                }
            }
        } else if (position !== undefined) {
            // non-indexed buffer geometry
            if (Array.isArray(material)) for(let i = 0, il = groups.length; i < il; i++){
                const group = groups[i];
                const groupMaterial = material[group.materialIndex];
                const start = Math.max(group.start, drawRange.start);
                const end = Math.min(position.count, Math.min(group.start + group.count, drawRange.start + drawRange.count));
                for(let j = start, jl = end; j < jl; j += 3){
                    const a = j;
                    const b = j + 1;
                    const c = j + 2;
                    intersection = $d5b85d29c0b78636$var$checkGeometryIntersection(this, groupMaterial, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
                    if (intersection) {
                        intersection.faceIndex = Math.floor(j / 3); // triangle number in non-indexed buffer semantics
                        intersection.face.materialIndex = group.materialIndex;
                        intersects.push(intersection);
                    }
                }
            }
            else {
                const start = Math.max(0, drawRange.start);
                const end = Math.min(position.count, drawRange.start + drawRange.count);
                for(let i = start, il = end; i < il; i += 3){
                    const a = i;
                    const b = i + 1;
                    const c = i + 2;
                    intersection = $d5b85d29c0b78636$var$checkGeometryIntersection(this, material, raycaster, rayLocalSpace, uv, uv1, normal, a, b, c);
                    if (intersection) {
                        intersection.faceIndex = Math.floor(i / 3); // triangle number in non-indexed buffer semantics
                        intersects.push(intersection);
                    }
                }
            }
        }
    }
}
function $d5b85d29c0b78636$var$checkIntersection$1(object, material, raycaster, ray, pA, pB, pC, point) {
    let intersect;
    if (material.side === $d5b85d29c0b78636$export$d9f0486e75b5ace) intersect = ray.intersectTriangle(pC, pB, pA, true, point);
    else intersect = ray.intersectTriangle(pA, pB, pC, material.side === $d5b85d29c0b78636$export$2ede184fc2998901, point);
    if (intersect === null) return null;
    $d5b85d29c0b78636$var$_intersectionPointWorld.copy(point);
    $d5b85d29c0b78636$var$_intersectionPointWorld.applyMatrix4(object.matrixWorld);
    const distance = raycaster.ray.origin.distanceTo($d5b85d29c0b78636$var$_intersectionPointWorld);
    if (distance < raycaster.near || distance > raycaster.far) return null;
    return {
        distance: distance,
        point: $d5b85d29c0b78636$var$_intersectionPointWorld.clone(),
        object: object
    };
}
function $d5b85d29c0b78636$var$checkGeometryIntersection(object, material, raycaster, ray, uv, uv1, normal, a, b, c) {
    object.getVertexPosition(a, $d5b85d29c0b78636$var$_vA$1);
    object.getVertexPosition(b, $d5b85d29c0b78636$var$_vB$1);
    object.getVertexPosition(c, $d5b85d29c0b78636$var$_vC$1);
    const intersection = $d5b85d29c0b78636$var$checkIntersection$1(object, material, raycaster, ray, $d5b85d29c0b78636$var$_vA$1, $d5b85d29c0b78636$var$_vB$1, $d5b85d29c0b78636$var$_vC$1, $d5b85d29c0b78636$var$_intersectionPoint);
    if (intersection) {
        const barycoord = new $d5b85d29c0b78636$export$64b5c384219d3699();
        $d5b85d29c0b78636$export$5a465592bfe74b48.getBarycoord($d5b85d29c0b78636$var$_intersectionPoint, $d5b85d29c0b78636$var$_vA$1, $d5b85d29c0b78636$var$_vB$1, $d5b85d29c0b78636$var$_vC$1, barycoord);
        if (uv) intersection.uv = $d5b85d29c0b78636$export$5a465592bfe74b48.getInterpolatedAttribute(uv, a, b, c, barycoord, new $d5b85d29c0b78636$export$c977b3e384af9ae1());
        if (uv1) intersection.uv1 = $d5b85d29c0b78636$export$5a465592bfe74b48.getInterpolatedAttribute(uv1, a, b, c, barycoord, new $d5b85d29c0b78636$export$c977b3e384af9ae1());
        if (normal) {
            intersection.normal = $d5b85d29c0b78636$export$5a465592bfe74b48.getInterpolatedAttribute(normal, a, b, c, barycoord, new $d5b85d29c0b78636$export$64b5c384219d3699());
            if (intersection.normal.dot(ray.direction) > 0) intersection.normal.multiplyScalar(-1);
        }
        const face = {
            a: a,
            b: b,
            c: c,
            normal: new $d5b85d29c0b78636$export$64b5c384219d3699(),
            materialIndex: 0
        };
        $d5b85d29c0b78636$export$5a465592bfe74b48.getNormal($d5b85d29c0b78636$var$_vA$1, $d5b85d29c0b78636$var$_vB$1, $d5b85d29c0b78636$var$_vC$1, face.normal);
        intersection.face = face;
        intersection.barycoord = barycoord;
    }
    return intersection;
}
class $d5b85d29c0b78636$export$33e43285f7406bd5 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(width = 1, height = 1, depth = 1, widthSegments = 1, heightSegments = 1, depthSegments = 1){
        super();
        this.type = 'BoxGeometry';
        this.parameters = {
            width: width,
            height: height,
            depth: depth,
            widthSegments: widthSegments,
            heightSegments: heightSegments,
            depthSegments: depthSegments
        };
        const scope = this;
        // segments
        widthSegments = Math.floor(widthSegments);
        heightSegments = Math.floor(heightSegments);
        depthSegments = Math.floor(depthSegments);
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // helper variables
        let numberOfVertices = 0;
        let groupStart = 0;
        // build each side of the box geometry
        buildPlane('z', 'y', 'x', -1, -1, depth, height, width, depthSegments, heightSegments, 0); // px
        buildPlane('z', 'y', 'x', 1, -1, depth, height, -width, depthSegments, heightSegments, 1); // nx
        buildPlane('x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2); // py
        buildPlane('x', 'z', 'y', 1, -1, width, depth, -height, widthSegments, depthSegments, 3); // ny
        buildPlane('x', 'y', 'z', 1, -1, width, height, depth, widthSegments, heightSegments, 4); // pz
        buildPlane('x', 'y', 'z', -1, -1, width, height, -depth, widthSegments, heightSegments, 5); // nz
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
        function buildPlane(u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex) {
            const segmentWidth = width / gridX;
            const segmentHeight = height / gridY;
            const widthHalf = width / 2;
            const heightHalf = height / 2;
            const depthHalf = depth / 2;
            const gridX1 = gridX + 1;
            const gridY1 = gridY + 1;
            let vertexCounter = 0;
            let groupCount = 0;
            const vector = new $d5b85d29c0b78636$export$64b5c384219d3699();
            // generate vertices, normals and uvs
            for(let iy = 0; iy < gridY1; iy++){
                const y = iy * segmentHeight - heightHalf;
                for(let ix = 0; ix < gridX1; ix++){
                    const x = ix * segmentWidth - widthHalf;
                    // set values to correct vector component
                    vector[u] = x * udir;
                    vector[v] = y * vdir;
                    vector[w] = depthHalf;
                    // now apply vector to vertex buffer
                    vertices.push(vector.x, vector.y, vector.z);
                    // set values to correct vector component
                    vector[u] = 0;
                    vector[v] = 0;
                    vector[w] = depth > 0 ? 1 : -1;
                    // now apply vector to normal buffer
                    normals.push(vector.x, vector.y, vector.z);
                    // uvs
                    uvs.push(ix / gridX);
                    uvs.push(1 - iy / gridY);
                    // counters
                    vertexCounter += 1;
                }
            }
            // indices
            // 1. you need three indices to draw a single face
            // 2. a single segment consists of two faces
            // 3. so we need to generate six (2*3) indices per segment
            for(let iy = 0; iy < gridY; iy++)for(let ix = 0; ix < gridX; ix++){
                const a = numberOfVertices + ix + gridX1 * iy;
                const b = numberOfVertices + ix + gridX1 * (iy + 1);
                const c = numberOfVertices + (ix + 1) + gridX1 * (iy + 1);
                const d = numberOfVertices + (ix + 1) + gridX1 * iy;
                // faces
                indices.push(a, b, d);
                indices.push(b, c, d);
                // increase counter
                groupCount += 6;
            }
            // add a group to the geometry. this will ensure multi material support
            scope.addGroup(groupStart, groupCount, materialIndex);
            // calculate new start value for groups
            groupStart += groupCount;
            // update total number of vertices
            numberOfVertices += vertexCounter;
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$33e43285f7406bd5(data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments);
    }
}
/**
 * Uniform Utilities
 */ function $d5b85d29c0b78636$export$acda854380553452(src) {
    const dst = {};
    for(const u in src){
        dst[u] = {};
        for(const p in src[u]){
            const property = src[u][p];
            if (property && (property.isColor || property.isMatrix3 || property.isMatrix4 || property.isVector2 || property.isVector3 || property.isVector4 || property.isTexture || property.isQuaternion)) {
                if (property.isRenderTargetTexture) {
                    console.warn('UniformsUtils: Textures of render targets cannot be cloned via cloneUniforms() or mergeUniforms().');
                    dst[u][p] = null;
                } else dst[u][p] = property.clone();
            } else if (Array.isArray(property)) dst[u][p] = property.slice();
            else dst[u][p] = property;
        }
    }
    return dst;
}
function $d5b85d29c0b78636$export$8916ce6879271f43(uniforms) {
    const merged = {};
    for(let u = 0; u < uniforms.length; u++){
        const tmp = $d5b85d29c0b78636$export$acda854380553452(uniforms[u]);
        for(const p in tmp)merged[p] = tmp[p];
    }
    return merged;
}
function $d5b85d29c0b78636$var$cloneUniformsGroups(src) {
    const dst = [];
    for(let u = 0; u < src.length; u++)dst.push(src[u].clone());
    return dst;
}
function $d5b85d29c0b78636$export$a630742c640528c1(renderer) {
    const currentRenderTarget = renderer.getRenderTarget();
    if (currentRenderTarget === null) // https://github.com/mrdoob/three.js/pull/23937#issuecomment-1111067398
    return renderer.outputColorSpace;
    // https://github.com/mrdoob/three.js/issues/27868
    if (currentRenderTarget.isXRRenderTarget === true) return currentRenderTarget.texture.colorSpace;
    return $d5b85d29c0b78636$export$5e6fd513f44698c.workingColorSpace;
}
// Legacy
const $d5b85d29c0b78636$export$d8ecdf8615bfea69 = {
    clone: $d5b85d29c0b78636$export$acda854380553452,
    merge: $d5b85d29c0b78636$export$8916ce6879271f43
};
var $d5b85d29c0b78636$var$default_vertex = "void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";
var $d5b85d29c0b78636$var$default_fragment = "void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}";
class $d5b85d29c0b78636$export$83c7d75d550a8b0d extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isShaderMaterial = true;
        this.type = 'ShaderMaterial';
        this.defines = {};
        this.uniforms = {};
        this.uniformsGroups = [];
        this.vertexShader = $d5b85d29c0b78636$var$default_vertex;
        this.fragmentShader = $d5b85d29c0b78636$var$default_fragment;
        this.linewidth = 1;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.fog = false; // set to use scene fog
        this.lights = false; // set to use scene lights
        this.clipping = false; // set to use user-defined clipping planes
        this.forceSinglePass = true;
        this.extensions = {
            clipCullDistance: false,
            multiDraw: false // set to use vertex shader multi_draw / enable gl_DrawID
        };
        // When rendered geometry doesn't include these attributes but the material does,
        // use these default values in WebGL. This avoids errors when buffer data is missing.
        this.defaultAttributeValues = {
            'color': [
                1,
                1,
                1
            ],
            'uv': [
                0,
                0
            ],
            'uv1': [
                0,
                0
            ]
        };
        this.index0AttributeName = undefined;
        this.uniformsNeedUpdate = false;
        this.glslVersion = null;
        if (parameters !== undefined) this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.fragmentShader = source.fragmentShader;
        this.vertexShader = source.vertexShader;
        this.uniforms = $d5b85d29c0b78636$export$acda854380553452(source.uniforms);
        this.uniformsGroups = $d5b85d29c0b78636$var$cloneUniformsGroups(source.uniformsGroups);
        this.defines = Object.assign({}, source.defines);
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.fog = source.fog;
        this.lights = source.lights;
        this.clipping = source.clipping;
        this.extensions = Object.assign({}, source.extensions);
        this.glslVersion = source.glslVersion;
        return this;
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        data.glslVersion = this.glslVersion;
        data.uniforms = {};
        for(const name in this.uniforms){
            const uniform = this.uniforms[name];
            const value = uniform.value;
            if (value && value.isTexture) data.uniforms[name] = {
                type: 't',
                value: value.toJSON(meta).uuid
            };
            else if (value && value.isColor) data.uniforms[name] = {
                type: 'c',
                value: value.getHex()
            };
            else if (value && value.isVector2) data.uniforms[name] = {
                type: 'v2',
                value: value.toArray()
            };
            else if (value && value.isVector3) data.uniforms[name] = {
                type: 'v3',
                value: value.toArray()
            };
            else if (value && value.isVector4) data.uniforms[name] = {
                type: 'v4',
                value: value.toArray()
            };
            else if (value && value.isMatrix3) data.uniforms[name] = {
                type: 'm3',
                value: value.toArray()
            };
            else if (value && value.isMatrix4) data.uniforms[name] = {
                type: 'm4',
                value: value.toArray()
            };
            else data.uniforms[name] = {
                value: value
            };
        }
        if (Object.keys(this.defines).length > 0) data.defines = this.defines;
        data.vertexShader = this.vertexShader;
        data.fragmentShader = this.fragmentShader;
        data.lights = this.lights;
        data.clipping = this.clipping;
        const extensions = {};
        for(const key in this.extensions)if (this.extensions[key] === true) extensions[key] = true;
        if (Object.keys(extensions).length > 0) data.extensions = extensions;
        return data;
    }
}
class $d5b85d29c0b78636$export$79f141de891a5fed extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(){
        super();
        this.isCamera = true;
        this.type = 'Camera';
        this.matrixWorldInverse = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.projectionMatrix = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.projectionMatrixInverse = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.coordinateSystem = $d5b85d29c0b78636$export$5a0e9190d10875d3;
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.matrixWorldInverse.copy(source.matrixWorldInverse);
        this.projectionMatrix.copy(source.projectionMatrix);
        this.projectionMatrixInverse.copy(source.projectionMatrixInverse);
        this.coordinateSystem = source.coordinateSystem;
        return this;
    }
    getWorldDirection(target) {
        return super.getWorldDirection(target).negate();
    }
    updateMatrixWorld(force) {
        super.updateMatrixWorld(force);
        this.matrixWorldInverse.copy(this.matrixWorld).invert();
    }
    updateWorldMatrix(updateParents, updateChildren) {
        super.updateWorldMatrix(updateParents, updateChildren);
        this.matrixWorldInverse.copy(this.matrixWorld).invert();
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
const $d5b85d29c0b78636$var$_v3$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_minTarget = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
const $d5b85d29c0b78636$var$_maxTarget = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
class $d5b85d29c0b78636$export$74e4ae24825f68d7 extends $d5b85d29c0b78636$export$79f141de891a5fed {
    constructor(fov = 50, aspect = 1, near = 0.1, far = 2000){
        super();
        this.isPerspectiveCamera = true;
        this.type = 'PerspectiveCamera';
        this.fov = fov;
        this.zoom = 1;
        this.near = near;
        this.far = far;
        this.focus = 10;
        this.aspect = aspect;
        this.view = null;
        this.filmGauge = 35; // width of the film (default in millimeters)
        this.filmOffset = 0; // horizontal film offset (same unit as gauge)
        this.updateProjectionMatrix();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.fov = source.fov;
        this.zoom = source.zoom;
        this.near = source.near;
        this.far = source.far;
        this.focus = source.focus;
        this.aspect = source.aspect;
        this.view = source.view === null ? null : Object.assign({}, source.view);
        this.filmGauge = source.filmGauge;
        this.filmOffset = source.filmOffset;
        return this;
    }
    /**
	 * Sets the FOV by focal length in respect to the current .filmGauge.
	 *
	 * The default film gauge is 35, so that the focal length can be specified for
	 * a 35mm (full frame) camera.
	 *
	 * @param {number} focalLength - Values for focal length and film gauge must have the same unit.
	 */ setFocalLength(focalLength) {
        /** see {@link http://www.bobatkins.com/photography/technical/field_of_view.html} */ const vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;
        this.fov = $d5b85d29c0b78636$export$914076c8150813e5 * 2 * Math.atan(vExtentSlope);
        this.updateProjectionMatrix();
    }
    /**
	 * Calculates the focal length from the current .fov and .filmGauge.
	 *
	 * @returns {number}
	 */ getFocalLength() {
        const vExtentSlope = Math.tan($d5b85d29c0b78636$var$DEG2RAD * 0.5 * this.fov);
        return 0.5 * this.getFilmHeight() / vExtentSlope;
    }
    getEffectiveFOV() {
        return $d5b85d29c0b78636$export$914076c8150813e5 * 2 * Math.atan(Math.tan($d5b85d29c0b78636$var$DEG2RAD * 0.5 * this.fov) / this.zoom);
    }
    getFilmWidth() {
        // film not completely covered in portrait format (aspect < 1)
        return this.filmGauge * Math.min(this.aspect, 1);
    }
    getFilmHeight() {
        // film not completely covered in landscape format (aspect > 1)
        return this.filmGauge / Math.max(this.aspect, 1);
    }
    /**
	 * Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction.
	 * Sets minTarget and maxTarget to the coordinates of the lower-left and upper-right corners of the view rectangle.
	 *
	 * @param {number} distance
	 * @param {Vector2} minTarget
	 * @param {Vector2} maxTarget
	 */ getViewBounds(distance, minTarget, maxTarget) {
        $d5b85d29c0b78636$var$_v3$1.set(-1, -1, 0.5).applyMatrix4(this.projectionMatrixInverse);
        minTarget.set($d5b85d29c0b78636$var$_v3$1.x, $d5b85d29c0b78636$var$_v3$1.y).multiplyScalar(-distance / $d5b85d29c0b78636$var$_v3$1.z);
        $d5b85d29c0b78636$var$_v3$1.set(1, 1, 0.5).applyMatrix4(this.projectionMatrixInverse);
        maxTarget.set($d5b85d29c0b78636$var$_v3$1.x, $d5b85d29c0b78636$var$_v3$1.y).multiplyScalar(-distance / $d5b85d29c0b78636$var$_v3$1.z);
    }
    /**
	 * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.
	 *
	 * @param {number} distance
	 * @param {Vector2} target - Vector2 target used to store result where x is width and y is height.
	 * @returns {Vector2}
	 */ getViewSize(distance, target) {
        this.getViewBounds(distance, $d5b85d29c0b78636$var$_minTarget, $d5b85d29c0b78636$var$_maxTarget);
        return target.subVectors($d5b85d29c0b78636$var$_maxTarget, $d5b85d29c0b78636$var$_minTarget);
    }
    /**
	 * Sets an offset in a larger frustum. This is useful for multi-window or
	 * multi-monitor/multi-machine setups.
	 *
	 * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
	 * the monitors are in grid like this
	 *
	 *   +---+---+---+
	 *   | A | B | C |
	 *   +---+---+---+
	 *   | D | E | F |
	 *   +---+---+---+
	 *
	 * then for each monitor you would call it like this
	 *
	 *   const w = 1920;
	 *   const h = 1080;
	 *   const fullWidth = w * 3;
	 *   const fullHeight = h * 2;
	 *
	 *   --A--
	 *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
	 *   --B--
	 *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
	 *   --C--
	 *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
	 *   --D--
	 *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
	 *   --E--
	 *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
	 *   --F--
	 *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
	 *
	 *   Note there is no reason monitors have to be the same size or in a grid.
	 *
	 * @param {number} fullWidth
	 * @param {number} fullHeight
	 * @param {number} x
	 * @param {number} y
	 * @param {number} width
	 * @param {number} height
	 */ setViewOffset(fullWidth, fullHeight, x, y, width, height) {
        this.aspect = fullWidth / fullHeight;
        if (this.view === null) this.view = {
            enabled: true,
            fullWidth: 1,
            fullHeight: 1,
            offsetX: 0,
            offsetY: 0,
            width: 1,
            height: 1
        };
        this.view.enabled = true;
        this.view.fullWidth = fullWidth;
        this.view.fullHeight = fullHeight;
        this.view.offsetX = x;
        this.view.offsetY = y;
        this.view.width = width;
        this.view.height = height;
        this.updateProjectionMatrix();
    }
    clearViewOffset() {
        if (this.view !== null) this.view.enabled = false;
        this.updateProjectionMatrix();
    }
    updateProjectionMatrix() {
        const near = this.near;
        let top = near * Math.tan($d5b85d29c0b78636$var$DEG2RAD * 0.5 * this.fov) / this.zoom;
        let height = 2 * top;
        let width = this.aspect * height;
        let left = -0.5 * width;
        const view = this.view;
        if (this.view !== null && this.view.enabled) {
            const fullWidth = view.fullWidth, fullHeight = view.fullHeight;
            left += view.offsetX * width / fullWidth;
            top -= view.offsetY * height / fullHeight;
            width *= view.width / fullWidth;
            height *= view.height / fullHeight;
        }
        const skew = this.filmOffset;
        if (skew !== 0) left += near * skew / this.getFilmWidth();
        this.projectionMatrix.makePerspective(left, left + width, top, top - height, near, this.far, this.coordinateSystem);
        this.projectionMatrixInverse.copy(this.projectionMatrix).invert();
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        data.object.fov = this.fov;
        data.object.zoom = this.zoom;
        data.object.near = this.near;
        data.object.far = this.far;
        data.object.focus = this.focus;
        data.object.aspect = this.aspect;
        if (this.view !== null) data.object.view = Object.assign({}, this.view);
        data.object.filmGauge = this.filmGauge;
        data.object.filmOffset = this.filmOffset;
        return data;
    }
}
const $d5b85d29c0b78636$var$fov = -90; // negative fov is not an error
const $d5b85d29c0b78636$var$aspect = 1;
class $d5b85d29c0b78636$export$d0cdd0bd804995de extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(near, far, renderTarget){
        super();
        this.type = 'CubeCamera';
        this.renderTarget = renderTarget;
        this.coordinateSystem = null;
        this.activeMipmapLevel = 0;
        const cameraPX = new $d5b85d29c0b78636$export$74e4ae24825f68d7($d5b85d29c0b78636$var$fov, $d5b85d29c0b78636$var$aspect, near, far);
        cameraPX.layers = this.layers;
        this.add(cameraPX);
        const cameraNX = new $d5b85d29c0b78636$export$74e4ae24825f68d7($d5b85d29c0b78636$var$fov, $d5b85d29c0b78636$var$aspect, near, far);
        cameraNX.layers = this.layers;
        this.add(cameraNX);
        const cameraPY = new $d5b85d29c0b78636$export$74e4ae24825f68d7($d5b85d29c0b78636$var$fov, $d5b85d29c0b78636$var$aspect, near, far);
        cameraPY.layers = this.layers;
        this.add(cameraPY);
        const cameraNY = new $d5b85d29c0b78636$export$74e4ae24825f68d7($d5b85d29c0b78636$var$fov, $d5b85d29c0b78636$var$aspect, near, far);
        cameraNY.layers = this.layers;
        this.add(cameraNY);
        const cameraPZ = new $d5b85d29c0b78636$export$74e4ae24825f68d7($d5b85d29c0b78636$var$fov, $d5b85d29c0b78636$var$aspect, near, far);
        cameraPZ.layers = this.layers;
        this.add(cameraPZ);
        const cameraNZ = new $d5b85d29c0b78636$export$74e4ae24825f68d7($d5b85d29c0b78636$var$fov, $d5b85d29c0b78636$var$aspect, near, far);
        cameraNZ.layers = this.layers;
        this.add(cameraNZ);
    }
    updateCoordinateSystem() {
        const coordinateSystem = this.coordinateSystem;
        const cameras = this.children.concat();
        const [cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ] = cameras;
        for (const camera of cameras)this.remove(camera);
        if (coordinateSystem === $d5b85d29c0b78636$export$5a0e9190d10875d3) {
            cameraPX.up.set(0, 1, 0);
            cameraPX.lookAt(1, 0, 0);
            cameraNX.up.set(0, 1, 0);
            cameraNX.lookAt(-1, 0, 0);
            cameraPY.up.set(0, 0, -1);
            cameraPY.lookAt(0, 1, 0);
            cameraNY.up.set(0, 0, 1);
            cameraNY.lookAt(0, -1, 0);
            cameraPZ.up.set(0, 1, 0);
            cameraPZ.lookAt(0, 0, 1);
            cameraNZ.up.set(0, 1, 0);
            cameraNZ.lookAt(0, 0, -1);
        } else if (coordinateSystem === $d5b85d29c0b78636$export$cc83beedcb9be9ac) {
            cameraPX.up.set(0, -1, 0);
            cameraPX.lookAt(-1, 0, 0);
            cameraNX.up.set(0, -1, 0);
            cameraNX.lookAt(1, 0, 0);
            cameraPY.up.set(0, 0, 1);
            cameraPY.lookAt(0, 1, 0);
            cameraNY.up.set(0, 0, -1);
            cameraNY.lookAt(0, -1, 0);
            cameraPZ.up.set(0, -1, 0);
            cameraPZ.lookAt(0, 0, 1);
            cameraNZ.up.set(0, -1, 0);
            cameraNZ.lookAt(0, 0, -1);
        } else throw new Error('THREE.CubeCamera.updateCoordinateSystem(): Invalid coordinate system: ' + coordinateSystem);
        for (const camera of cameras){
            this.add(camera);
            camera.updateMatrixWorld();
        }
    }
    update(renderer, scene) {
        if (this.parent === null) this.updateMatrixWorld();
        const { renderTarget: renderTarget, activeMipmapLevel: activeMipmapLevel } = this;
        if (this.coordinateSystem !== renderer.coordinateSystem) {
            this.coordinateSystem = renderer.coordinateSystem;
            this.updateCoordinateSystem();
        }
        const [cameraPX, cameraNX, cameraPY, cameraNY, cameraPZ, cameraNZ] = this.children;
        const currentRenderTarget = renderer.getRenderTarget();
        const currentActiveCubeFace = renderer.getActiveCubeFace();
        const currentActiveMipmapLevel = renderer.getActiveMipmapLevel();
        const currentXrEnabled = renderer.xr.enabled;
        renderer.xr.enabled = false;
        const generateMipmaps = renderTarget.texture.generateMipmaps;
        renderTarget.texture.generateMipmaps = false;
        renderer.setRenderTarget(renderTarget, 0, activeMipmapLevel);
        renderer.render(scene, cameraPX);
        renderer.setRenderTarget(renderTarget, 1, activeMipmapLevel);
        renderer.render(scene, cameraNX);
        renderer.setRenderTarget(renderTarget, 2, activeMipmapLevel);
        renderer.render(scene, cameraPY);
        renderer.setRenderTarget(renderTarget, 3, activeMipmapLevel);
        renderer.render(scene, cameraNY);
        renderer.setRenderTarget(renderTarget, 4, activeMipmapLevel);
        renderer.render(scene, cameraPZ);
        // mipmaps are generated during the last call of render()
        // at this point, all sides of the cube render target are defined
        renderTarget.texture.generateMipmaps = generateMipmaps;
        renderer.setRenderTarget(renderTarget, 5, activeMipmapLevel);
        renderer.render(scene, cameraNZ);
        renderer.setRenderTarget(currentRenderTarget, currentActiveCubeFace, currentActiveMipmapLevel);
        renderer.xr.enabled = currentXrEnabled;
        renderTarget.texture.needsPMREMUpdate = true;
    }
}
class $d5b85d29c0b78636$export$ee2e5a18258a4049 extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace){
        images = images !== undefined ? images : [];
        mapping = mapping !== undefined ? mapping : $d5b85d29c0b78636$export$8759762a6477f2c4;
        super(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
        this.isCubeTexture = true;
        this.flipY = false;
    }
    get images() {
        return this.image;
    }
    set images(value) {
        this.image = value;
    }
}
class $d5b85d29c0b78636$export$ac386671d651941e extends $d5b85d29c0b78636$export$3c052beb2e51e23f {
    constructor(size = 1, options = {}){
        super(size, size, options);
        this.isWebGLCubeRenderTarget = true;
        const image = {
            width: size,
            height: size,
            depth: 1
        };
        const images = [
            image,
            image,
            image,
            image,
            image,
            image
        ];
        this.texture = new $d5b85d29c0b78636$export$ee2e5a18258a4049(images, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace);
        // By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)
        // in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,
        // in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.
        // three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
        // and the flag isRenderTargetTexture controls this conversion. The flip is not required when using WebGLCubeRenderTarget.texture
        // as a cube texture (this is detected when isRenderTargetTexture is set to true for cube textures).
        this.texture.isRenderTargetTexture = true;
        this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
        this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : $d5b85d29c0b78636$export$8a72f490b25c56c8;
    }
    fromEquirectangularTexture(renderer, texture) {
        this.texture.type = texture.type;
        this.texture.colorSpace = texture.colorSpace;
        this.texture.generateMipmaps = texture.generateMipmaps;
        this.texture.minFilter = texture.minFilter;
        this.texture.magFilter = texture.magFilter;
        const shader = {
            uniforms: {
                tEquirect: {
                    value: null
                }
            },
            vertexShader: /* glsl */ `

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,
            fragmentShader: /* glsl */ `

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`
        };
        const geometry = new $d5b85d29c0b78636$export$33e43285f7406bd5(5, 5, 5);
        const material = new $d5b85d29c0b78636$export$83c7d75d550a8b0d({
            name: 'CubemapFromEquirect',
            uniforms: $d5b85d29c0b78636$export$acda854380553452(shader.uniforms),
            vertexShader: shader.vertexShader,
            fragmentShader: shader.fragmentShader,
            side: $d5b85d29c0b78636$export$d9f0486e75b5ace,
            blending: $d5b85d29c0b78636$export$63b8d6b580fc65ba
        });
        material.uniforms.tEquirect.value = texture;
        const mesh = new $d5b85d29c0b78636$export$e176487c05830cc5(geometry, material);
        const currentMinFilter = texture.minFilter;
        // Avoid blurred poles
        if (texture.minFilter === $d5b85d29c0b78636$export$5d8599b6a933fb1b) texture.minFilter = $d5b85d29c0b78636$export$8a72f490b25c56c8;
        const camera = new $d5b85d29c0b78636$export$d0cdd0bd804995de(1, 10, this);
        camera.update(renderer, mesh);
        texture.minFilter = currentMinFilter;
        mesh.geometry.dispose();
        mesh.material.dispose();
        return this;
    }
    clear(renderer, color, depth, stencil) {
        const currentRenderTarget = renderer.getRenderTarget();
        for(let i = 0; i < 6; i++){
            renderer.setRenderTarget(this, i);
            renderer.clear(color, depth, stencil);
        }
        renderer.setRenderTarget(currentRenderTarget);
    }
}
class $d5b85d29c0b78636$export$6f1519f023b8d0f6 {
    constructor(color, density = 0.00025){
        this.isFogExp2 = true;
        this.name = '';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(color);
        this.density = density;
    }
    clone() {
        return new $d5b85d29c0b78636$export$6f1519f023b8d0f6(this.color, this.density);
    }
    toJSON() {
        return {
            type: 'FogExp2',
            name: this.name,
            color: this.color.getHex(),
            density: this.density
        };
    }
}
class $d5b85d29c0b78636$export$3c890837b09508d4 {
    constructor(color, near = 1, far = 1000){
        this.isFog = true;
        this.name = '';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(color);
        this.near = near;
        this.far = far;
    }
    clone() {
        return new $d5b85d29c0b78636$export$3c890837b09508d4(this.color, this.near, this.far);
    }
    toJSON() {
        return {
            type: 'Fog',
            name: this.name,
            color: this.color.getHex(),
            near: this.near,
            far: this.far
        };
    }
}
class $d5b85d29c0b78636$export$38af1803e3442a7f extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(){
        super();
        this.isScene = true;
        this.type = 'Scene';
        this.background = null;
        this.environment = null;
        this.fog = null;
        this.backgroundBlurriness = 0;
        this.backgroundIntensity = 1;
        this.backgroundRotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        this.environmentIntensity = 1;
        this.environmentRotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        this.overrideMaterial = null;
        if (typeof __THREE_DEVTOOLS__ !== 'undefined') __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent('observe', {
            detail: this
        }));
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        if (source.background !== null) this.background = source.background.clone();
        if (source.environment !== null) this.environment = source.environment.clone();
        if (source.fog !== null) this.fog = source.fog.clone();
        this.backgroundBlurriness = source.backgroundBlurriness;
        this.backgroundIntensity = source.backgroundIntensity;
        this.backgroundRotation.copy(source.backgroundRotation);
        this.environmentIntensity = source.environmentIntensity;
        this.environmentRotation.copy(source.environmentRotation);
        if (source.overrideMaterial !== null) this.overrideMaterial = source.overrideMaterial.clone();
        this.matrixAutoUpdate = source.matrixAutoUpdate;
        return this;
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        if (this.fog !== null) data.object.fog = this.fog.toJSON();
        if (this.backgroundBlurriness > 0) data.object.backgroundBlurriness = this.backgroundBlurriness;
        if (this.backgroundIntensity !== 1) data.object.backgroundIntensity = this.backgroundIntensity;
        data.object.backgroundRotation = this.backgroundRotation.toArray();
        if (this.environmentIntensity !== 1) data.object.environmentIntensity = this.environmentIntensity;
        data.object.environmentRotation = this.environmentRotation.toArray();
        return data;
    }
}
class $d5b85d29c0b78636$export$3d5cd879f108f53f {
    constructor(array, stride){
        this.isInterleavedBuffer = true;
        this.array = array;
        this.stride = stride;
        this.count = array !== undefined ? array.length / stride : 0;
        this.usage = $d5b85d29c0b78636$export$763e8360f4d7f77d;
        this.updateRanges = [];
        this.version = 0;
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
    }
    onUploadCallback() {}
    set needsUpdate(value) {
        if (value === true) this.version++;
    }
    setUsage(value) {
        this.usage = value;
        return this;
    }
    addUpdateRange(start, count) {
        this.updateRanges.push({
            start: start,
            count: count
        });
    }
    clearUpdateRanges() {
        this.updateRanges.length = 0;
    }
    copy(source) {
        this.array = new source.array.constructor(source.array);
        this.count = source.count;
        this.stride = source.stride;
        this.usage = source.usage;
        return this;
    }
    copyAt(index1, attribute, index2) {
        index1 *= this.stride;
        index2 *= attribute.stride;
        for(let i = 0, l = this.stride; i < l; i++)this.array[index1 + i] = attribute.array[index2 + i];
        return this;
    }
    set(value, offset = 0) {
        this.array.set(value, offset);
        return this;
    }
    clone(data) {
        if (data.arrayBuffers === undefined) data.arrayBuffers = {};
        if (this.array.buffer._uuid === undefined) this.array.buffer._uuid = $d5b85d29c0b78636$var$generateUUID();
        if (data.arrayBuffers[this.array.buffer._uuid] === undefined) data.arrayBuffers[this.array.buffer._uuid] = this.array.slice(0).buffer;
        const array = new this.array.constructor(data.arrayBuffers[this.array.buffer._uuid]);
        const ib = new this.constructor(array, this.stride);
        ib.setUsage(this.usage);
        return ib;
    }
    onUpload(callback) {
        this.onUploadCallback = callback;
        return this;
    }
    toJSON(data) {
        if (data.arrayBuffers === undefined) data.arrayBuffers = {};
        // generate UUID for array buffer if necessary
        if (this.array.buffer._uuid === undefined) this.array.buffer._uuid = $d5b85d29c0b78636$var$generateUUID();
        if (data.arrayBuffers[this.array.buffer._uuid] === undefined) data.arrayBuffers[this.array.buffer._uuid] = Array.from(new Uint32Array(this.array.buffer));
        //
        return {
            uuid: this.uuid,
            buffer: this.array.buffer._uuid,
            type: this.array.constructor.name,
            stride: this.stride
        };
    }
}
const $d5b85d29c0b78636$var$_vector$7 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$920b6d07334599c7 {
    constructor(interleavedBuffer, itemSize, offset, normalized = false){
        this.isInterleavedBufferAttribute = true;
        this.name = '';
        this.data = interleavedBuffer;
        this.itemSize = itemSize;
        this.offset = offset;
        this.normalized = normalized;
    }
    get count() {
        return this.data.count;
    }
    get array() {
        return this.data.array;
    }
    set needsUpdate(value) {
        this.data.needsUpdate = value;
    }
    applyMatrix4(m) {
        for(let i = 0, l = this.data.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$7.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$7.applyMatrix4(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$7.x, $d5b85d29c0b78636$var$_vector$7.y, $d5b85d29c0b78636$var$_vector$7.z);
        }
        return this;
    }
    applyNormalMatrix(m) {
        for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$7.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$7.applyNormalMatrix(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$7.x, $d5b85d29c0b78636$var$_vector$7.y, $d5b85d29c0b78636$var$_vector$7.z);
        }
        return this;
    }
    transformDirection(m) {
        for(let i = 0, l = this.count; i < l; i++){
            $d5b85d29c0b78636$var$_vector$7.fromBufferAttribute(this, i);
            $d5b85d29c0b78636$var$_vector$7.transformDirection(m);
            this.setXYZ(i, $d5b85d29c0b78636$var$_vector$7.x, $d5b85d29c0b78636$var$_vector$7.y, $d5b85d29c0b78636$var$_vector$7.z);
        }
        return this;
    }
    getComponent(index, component) {
        let value = this.array[index * this.data.stride + this.offset + component];
        if (this.normalized) value = $d5b85d29c0b78636$var$denormalize(value, this.array);
        return value;
    }
    setComponent(index, component, value) {
        if (this.normalized) value = $d5b85d29c0b78636$var$normalize(value, this.array);
        this.data.array[index * this.data.stride + this.offset + component] = value;
        return this;
    }
    setX(index, x) {
        if (this.normalized) x = $d5b85d29c0b78636$var$normalize(x, this.array);
        this.data.array[index * this.data.stride + this.offset] = x;
        return this;
    }
    setY(index, y) {
        if (this.normalized) y = $d5b85d29c0b78636$var$normalize(y, this.array);
        this.data.array[index * this.data.stride + this.offset + 1] = y;
        return this;
    }
    setZ(index, z) {
        if (this.normalized) z = $d5b85d29c0b78636$var$normalize(z, this.array);
        this.data.array[index * this.data.stride + this.offset + 2] = z;
        return this;
    }
    setW(index, w) {
        if (this.normalized) w = $d5b85d29c0b78636$var$normalize(w, this.array);
        this.data.array[index * this.data.stride + this.offset + 3] = w;
        return this;
    }
    getX(index) {
        let x = this.data.array[index * this.data.stride + this.offset];
        if (this.normalized) x = $d5b85d29c0b78636$var$denormalize(x, this.array);
        return x;
    }
    getY(index) {
        let y = this.data.array[index * this.data.stride + this.offset + 1];
        if (this.normalized) y = $d5b85d29c0b78636$var$denormalize(y, this.array);
        return y;
    }
    getZ(index) {
        let z = this.data.array[index * this.data.stride + this.offset + 2];
        if (this.normalized) z = $d5b85d29c0b78636$var$denormalize(z, this.array);
        return z;
    }
    getW(index) {
        let w = this.data.array[index * this.data.stride + this.offset + 3];
        if (this.normalized) w = $d5b85d29c0b78636$var$denormalize(w, this.array);
        return w;
    }
    setXY(index, x, y) {
        index = index * this.data.stride + this.offset;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
        }
        this.data.array[index + 0] = x;
        this.data.array[index + 1] = y;
        return this;
    }
    setXYZ(index, x, y, z) {
        index = index * this.data.stride + this.offset;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
            z = $d5b85d29c0b78636$var$normalize(z, this.array);
        }
        this.data.array[index + 0] = x;
        this.data.array[index + 1] = y;
        this.data.array[index + 2] = z;
        return this;
    }
    setXYZW(index, x, y, z, w) {
        index = index * this.data.stride + this.offset;
        if (this.normalized) {
            x = $d5b85d29c0b78636$var$normalize(x, this.array);
            y = $d5b85d29c0b78636$var$normalize(y, this.array);
            z = $d5b85d29c0b78636$var$normalize(z, this.array);
            w = $d5b85d29c0b78636$var$normalize(w, this.array);
        }
        this.data.array[index + 0] = x;
        this.data.array[index + 1] = y;
        this.data.array[index + 2] = z;
        this.data.array[index + 3] = w;
        return this;
    }
    clone(data) {
        if (data === undefined) {
            console.log('THREE.InterleavedBufferAttribute.clone(): Cloning an interleaved buffer attribute will de-interleave buffer data.');
            const array = [];
            for(let i = 0; i < this.count; i++){
                const index = i * this.data.stride + this.offset;
                for(let j = 0; j < this.itemSize; j++)array.push(this.data.array[index + j]);
            }
            return new $d5b85d29c0b78636$export$8dea267bd6bde117(new this.array.constructor(array), this.itemSize, this.normalized);
        } else {
            if (data.interleavedBuffers === undefined) data.interleavedBuffers = {};
            if (data.interleavedBuffers[this.data.uuid] === undefined) data.interleavedBuffers[this.data.uuid] = this.data.clone(data);
            return new $d5b85d29c0b78636$export$920b6d07334599c7(data.interleavedBuffers[this.data.uuid], this.itemSize, this.offset, this.normalized);
        }
    }
    toJSON(data) {
        if (data === undefined) {
            console.log('THREE.InterleavedBufferAttribute.toJSON(): Serializing an interleaved buffer attribute will de-interleave buffer data.');
            const array = [];
            for(let i = 0; i < this.count; i++){
                const index = i * this.data.stride + this.offset;
                for(let j = 0; j < this.itemSize; j++)array.push(this.data.array[index + j]);
            }
            // de-interleave data and save it as an ordinary buffer attribute for now
            return {
                itemSize: this.itemSize,
                type: this.array.constructor.name,
                array: array,
                normalized: this.normalized
            };
        } else {
            // save as true interleaved attribute
            if (data.interleavedBuffers === undefined) data.interleavedBuffers = {};
            if (data.interleavedBuffers[this.data.uuid] === undefined) data.interleavedBuffers[this.data.uuid] = this.data.toJSON(data);
            return {
                isInterleavedBufferAttribute: true,
                itemSize: this.itemSize,
                data: this.data.uuid,
                offset: this.offset,
                normalized: this.normalized
            };
        }
    }
}
class $d5b85d29c0b78636$export$5ec7dd1c6994bf8e extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isSpriteMaterial = true;
        this.type = 'SpriteMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff);
        this.map = null;
        this.alphaMap = null;
        this.rotation = 0;
        this.sizeAttenuation = true;
        this.transparent = true;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.map = source.map;
        this.alphaMap = source.alphaMap;
        this.rotation = source.rotation;
        this.sizeAttenuation = source.sizeAttenuation;
        this.fog = source.fog;
        return this;
    }
}
let $d5b85d29c0b78636$var$_geometry;
const $d5b85d29c0b78636$var$_intersectPoint = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_worldScale = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_mvPosition = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_alignedPosition = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
const $d5b85d29c0b78636$var$_rotatedPosition = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
const $d5b85d29c0b78636$var$_viewWorldMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_vA = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vB = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vC = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_uvA = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
const $d5b85d29c0b78636$var$_uvB = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
const $d5b85d29c0b78636$var$_uvC = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
class $d5b85d29c0b78636$export$3075603db8e6204c extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(material = new $d5b85d29c0b78636$export$5ec7dd1c6994bf8e()){
        super();
        this.isSprite = true;
        this.type = 'Sprite';
        if ($d5b85d29c0b78636$var$_geometry === undefined) {
            $d5b85d29c0b78636$var$_geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
            const float32Array = new Float32Array([
                -0.5,
                -0.5,
                0,
                0,
                0,
                0.5,
                -0.5,
                0,
                1,
                0,
                0.5,
                0.5,
                0,
                1,
                1,
                -0.5,
                0.5,
                0,
                0,
                1
            ]);
            const interleavedBuffer = new $d5b85d29c0b78636$export$3d5cd879f108f53f(float32Array, 5);
            $d5b85d29c0b78636$var$_geometry.setIndex([
                0,
                1,
                2,
                0,
                2,
                3
            ]);
            $d5b85d29c0b78636$var$_geometry.setAttribute('position', new $d5b85d29c0b78636$export$920b6d07334599c7(interleavedBuffer, 3, 0, false));
            $d5b85d29c0b78636$var$_geometry.setAttribute('uv', new $d5b85d29c0b78636$export$920b6d07334599c7(interleavedBuffer, 2, 3, false));
        }
        this.geometry = $d5b85d29c0b78636$var$_geometry;
        this.material = material;
        this.center = new $d5b85d29c0b78636$export$c977b3e384af9ae1(0.5, 0.5);
    }
    raycast(raycaster, intersects) {
        if (raycaster.camera === null) console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.');
        $d5b85d29c0b78636$var$_worldScale.setFromMatrixScale(this.matrixWorld);
        $d5b85d29c0b78636$var$_viewWorldMatrix.copy(raycaster.camera.matrixWorld);
        this.modelViewMatrix.multiplyMatrices(raycaster.camera.matrixWorldInverse, this.matrixWorld);
        $d5b85d29c0b78636$var$_mvPosition.setFromMatrixPosition(this.modelViewMatrix);
        if (raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false) $d5b85d29c0b78636$var$_worldScale.multiplyScalar(-$d5b85d29c0b78636$var$_mvPosition.z);
        const rotation = this.material.rotation;
        let sin, cos;
        if (rotation !== 0) {
            cos = Math.cos(rotation);
            sin = Math.sin(rotation);
        }
        const center = this.center;
        $d5b85d29c0b78636$var$transformVertex($d5b85d29c0b78636$var$_vA.set(-0.5, -0.5, 0), $d5b85d29c0b78636$var$_mvPosition, center, $d5b85d29c0b78636$var$_worldScale, sin, cos);
        $d5b85d29c0b78636$var$transformVertex($d5b85d29c0b78636$var$_vB.set(0.5, -0.5, 0), $d5b85d29c0b78636$var$_mvPosition, center, $d5b85d29c0b78636$var$_worldScale, sin, cos);
        $d5b85d29c0b78636$var$transformVertex($d5b85d29c0b78636$var$_vC.set(0.5, 0.5, 0), $d5b85d29c0b78636$var$_mvPosition, center, $d5b85d29c0b78636$var$_worldScale, sin, cos);
        $d5b85d29c0b78636$var$_uvA.set(0, 0);
        $d5b85d29c0b78636$var$_uvB.set(1, 0);
        $d5b85d29c0b78636$var$_uvC.set(1, 1);
        // check first triangle
        let intersect = raycaster.ray.intersectTriangle($d5b85d29c0b78636$var$_vA, $d5b85d29c0b78636$var$_vB, $d5b85d29c0b78636$var$_vC, false, $d5b85d29c0b78636$var$_intersectPoint);
        if (intersect === null) {
            // check second triangle
            $d5b85d29c0b78636$var$transformVertex($d5b85d29c0b78636$var$_vB.set(-0.5, 0.5, 0), $d5b85d29c0b78636$var$_mvPosition, center, $d5b85d29c0b78636$var$_worldScale, sin, cos);
            $d5b85d29c0b78636$var$_uvB.set(0, 1);
            intersect = raycaster.ray.intersectTriangle($d5b85d29c0b78636$var$_vA, $d5b85d29c0b78636$var$_vC, $d5b85d29c0b78636$var$_vB, false, $d5b85d29c0b78636$var$_intersectPoint);
            if (intersect === null) return;
        }
        const distance = raycaster.ray.origin.distanceTo($d5b85d29c0b78636$var$_intersectPoint);
        if (distance < raycaster.near || distance > raycaster.far) return;
        intersects.push({
            distance: distance,
            point: $d5b85d29c0b78636$var$_intersectPoint.clone(),
            uv: $d5b85d29c0b78636$export$5a465592bfe74b48.getInterpolation($d5b85d29c0b78636$var$_intersectPoint, $d5b85d29c0b78636$var$_vA, $d5b85d29c0b78636$var$_vB, $d5b85d29c0b78636$var$_vC, $d5b85d29c0b78636$var$_uvA, $d5b85d29c0b78636$var$_uvB, $d5b85d29c0b78636$var$_uvC, new $d5b85d29c0b78636$export$c977b3e384af9ae1()),
            face: null,
            object: this
        });
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        if (source.center !== undefined) this.center.copy(source.center);
        this.material = source.material;
        return this;
    }
}
function $d5b85d29c0b78636$var$transformVertex(vertexPosition, mvPosition, center, scale, sin, cos) {
    // compute position in camera space
    $d5b85d29c0b78636$var$_alignedPosition.subVectors(vertexPosition, center).addScalar(0.5).multiply(scale);
    // to check if rotation is not zero
    if (sin !== undefined) {
        $d5b85d29c0b78636$var$_rotatedPosition.x = cos * $d5b85d29c0b78636$var$_alignedPosition.x - sin * $d5b85d29c0b78636$var$_alignedPosition.y;
        $d5b85d29c0b78636$var$_rotatedPosition.y = sin * $d5b85d29c0b78636$var$_alignedPosition.x + cos * $d5b85d29c0b78636$var$_alignedPosition.y;
    } else $d5b85d29c0b78636$var$_rotatedPosition.copy($d5b85d29c0b78636$var$_alignedPosition);
    vertexPosition.copy(mvPosition);
    vertexPosition.x += $d5b85d29c0b78636$var$_rotatedPosition.x;
    vertexPosition.y += $d5b85d29c0b78636$var$_rotatedPosition.y;
    // transform to world space
    vertexPosition.applyMatrix4($d5b85d29c0b78636$var$_viewWorldMatrix);
}
const $d5b85d29c0b78636$var$_v1$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v2$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$112e7237be0c5f30 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(){
        super();
        this._currentLevel = 0;
        this.type = 'LOD';
        Object.defineProperties(this, {
            levels: {
                enumerable: true,
                value: []
            },
            isLOD: {
                value: true
            }
        });
        this.autoUpdate = true;
    }
    copy(source) {
        super.copy(source, false);
        const levels = source.levels;
        for(let i = 0, l = levels.length; i < l; i++){
            const level = levels[i];
            this.addLevel(level.object.clone(), level.distance, level.hysteresis);
        }
        this.autoUpdate = source.autoUpdate;
        return this;
    }
    addLevel(object, distance = 0, hysteresis = 0) {
        distance = Math.abs(distance);
        const levels = this.levels;
        let l;
        for(l = 0; l < levels.length; l++){
            if (distance < levels[l].distance) break;
        }
        levels.splice(l, 0, {
            distance: distance,
            hysteresis: hysteresis,
            object: object
        });
        this.add(object);
        return this;
    }
    removeLevel(distance) {
        const levels = this.levels;
        for(let i = 0; i < levels.length; i++)if (levels[i].distance === distance) {
            const removedElements = levels.splice(i, 1);
            this.remove(removedElements[0].object);
            return true;
        }
        return false;
    }
    getCurrentLevel() {
        return this._currentLevel;
    }
    getObjectForDistance(distance) {
        const levels = this.levels;
        if (levels.length > 0) {
            let i, l;
            for(i = 1, l = levels.length; i < l; i++){
                let levelDistance = levels[i].distance;
                if (levels[i].object.visible) levelDistance -= levelDistance * levels[i].hysteresis;
                if (distance < levelDistance) break;
            }
            return levels[i - 1].object;
        }
        return null;
    }
    raycast(raycaster, intersects) {
        const levels = this.levels;
        if (levels.length > 0) {
            $d5b85d29c0b78636$var$_v1$2.setFromMatrixPosition(this.matrixWorld);
            const distance = raycaster.ray.origin.distanceTo($d5b85d29c0b78636$var$_v1$2);
            this.getObjectForDistance(distance).raycast(raycaster, intersects);
        }
    }
    update(camera) {
        const levels = this.levels;
        if (levels.length > 1) {
            $d5b85d29c0b78636$var$_v1$2.setFromMatrixPosition(camera.matrixWorld);
            $d5b85d29c0b78636$var$_v2$1.setFromMatrixPosition(this.matrixWorld);
            const distance = $d5b85d29c0b78636$var$_v1$2.distanceTo($d5b85d29c0b78636$var$_v2$1) / camera.zoom;
            levels[0].object.visible = true;
            let i, l;
            for(i = 1, l = levels.length; i < l; i++){
                let levelDistance = levels[i].distance;
                if (levels[i].object.visible) levelDistance -= levelDistance * levels[i].hysteresis;
                if (distance >= levelDistance) {
                    levels[i - 1].object.visible = false;
                    levels[i].object.visible = true;
                } else break;
            }
            this._currentLevel = i - 1;
            for(; i < l; i++)levels[i].object.visible = false;
        }
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        if (this.autoUpdate === false) data.object.autoUpdate = false;
        data.object.levels = [];
        const levels = this.levels;
        for(let i = 0, l = levels.length; i < l; i++){
            const level = levels[i];
            data.object.levels.push({
                object: level.object.uuid,
                distance: level.distance,
                hysteresis: level.hysteresis
            });
        }
        return data;
    }
}
const $d5b85d29c0b78636$var$_basePosition = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_skinIndex = /*@__PURE__*/ new $d5b85d29c0b78636$export$fa7daccca11cdbe3();
const $d5b85d29c0b78636$var$_skinWeight = /*@__PURE__*/ new $d5b85d29c0b78636$export$fa7daccca11cdbe3();
const $d5b85d29c0b78636$var$_vector3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_matrix4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_vertex = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_sphere$5 = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
const $d5b85d29c0b78636$var$_inverseMatrix$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_ray$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$a186db52eed6d40e();
class $d5b85d29c0b78636$export$b303577035157ecf extends $d5b85d29c0b78636$export$e176487c05830cc5 {
    constructor(geometry, material){
        super(geometry, material);
        this.isSkinnedMesh = true;
        this.type = 'SkinnedMesh';
        this.bindMode = $d5b85d29c0b78636$export$2595a3798997538;
        this.bindMatrix = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.bindMatrixInverse = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.boundingBox = null;
        this.boundingSphere = null;
    }
    computeBoundingBox() {
        const geometry = this.geometry;
        if (this.boundingBox === null) this.boundingBox = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
        this.boundingBox.makeEmpty();
        const positionAttribute = geometry.getAttribute('position');
        for(let i = 0; i < positionAttribute.count; i++){
            this.getVertexPosition(i, $d5b85d29c0b78636$var$_vertex);
            this.boundingBox.expandByPoint($d5b85d29c0b78636$var$_vertex);
        }
    }
    computeBoundingSphere() {
        const geometry = this.geometry;
        if (this.boundingSphere === null) this.boundingSphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
        this.boundingSphere.makeEmpty();
        const positionAttribute = geometry.getAttribute('position');
        for(let i = 0; i < positionAttribute.count; i++){
            this.getVertexPosition(i, $d5b85d29c0b78636$var$_vertex);
            this.boundingSphere.expandByPoint($d5b85d29c0b78636$var$_vertex);
        }
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.bindMode = source.bindMode;
        this.bindMatrix.copy(source.bindMatrix);
        this.bindMatrixInverse.copy(source.bindMatrixInverse);
        this.skeleton = source.skeleton;
        if (source.boundingBox !== null) this.boundingBox = source.boundingBox.clone();
        if (source.boundingSphere !== null) this.boundingSphere = source.boundingSphere.clone();
        return this;
    }
    raycast(raycaster, intersects) {
        const material = this.material;
        const matrixWorld = this.matrixWorld;
        if (material === undefined) return;
        // test with bounding sphere in world space
        if (this.boundingSphere === null) this.computeBoundingSphere();
        $d5b85d29c0b78636$var$_sphere$5.copy(this.boundingSphere);
        $d5b85d29c0b78636$var$_sphere$5.applyMatrix4(matrixWorld);
        if (raycaster.ray.intersectsSphere($d5b85d29c0b78636$var$_sphere$5) === false) return;
        // convert ray to local space of skinned mesh
        $d5b85d29c0b78636$var$_inverseMatrix$2.copy(matrixWorld).invert();
        $d5b85d29c0b78636$var$_ray$2.copy(raycaster.ray).applyMatrix4($d5b85d29c0b78636$var$_inverseMatrix$2);
        // test with bounding box in local space
        if (this.boundingBox !== null) {
            if ($d5b85d29c0b78636$var$_ray$2.intersectsBox(this.boundingBox) === false) return;
        }
        // test for intersections with geometry
        this._computeIntersections(raycaster, intersects, $d5b85d29c0b78636$var$_ray$2);
    }
    getVertexPosition(index, target) {
        super.getVertexPosition(index, target);
        this.applyBoneTransform(index, target);
        return target;
    }
    bind(skeleton, bindMatrix) {
        this.skeleton = skeleton;
        if (bindMatrix === undefined) {
            this.updateMatrixWorld(true);
            this.skeleton.calculateInverses();
            bindMatrix = this.matrixWorld;
        }
        this.bindMatrix.copy(bindMatrix);
        this.bindMatrixInverse.copy(bindMatrix).invert();
    }
    pose() {
        this.skeleton.pose();
    }
    normalizeSkinWeights() {
        const vector = new $d5b85d29c0b78636$export$fa7daccca11cdbe3();
        const skinWeight = this.geometry.attributes.skinWeight;
        for(let i = 0, l = skinWeight.count; i < l; i++){
            vector.fromBufferAttribute(skinWeight, i);
            const scale = 1.0 / vector.manhattanLength();
            if (scale !== Infinity) vector.multiplyScalar(scale);
            else vector.set(1, 0, 0, 0); // do something reasonable
            skinWeight.setXYZW(i, vector.x, vector.y, vector.z, vector.w);
        }
    }
    updateMatrixWorld(force) {
        super.updateMatrixWorld(force);
        if (this.bindMode === $d5b85d29c0b78636$export$2595a3798997538) this.bindMatrixInverse.copy(this.matrixWorld).invert();
        else if (this.bindMode === $d5b85d29c0b78636$export$d7e7dc2e114517a0) this.bindMatrixInverse.copy(this.bindMatrix).invert();
        else console.warn('THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode);
    }
    applyBoneTransform(index, vector) {
        const skeleton = this.skeleton;
        const geometry = this.geometry;
        $d5b85d29c0b78636$var$_skinIndex.fromBufferAttribute(geometry.attributes.skinIndex, index);
        $d5b85d29c0b78636$var$_skinWeight.fromBufferAttribute(geometry.attributes.skinWeight, index);
        $d5b85d29c0b78636$var$_basePosition.copy(vector).applyMatrix4(this.bindMatrix);
        vector.set(0, 0, 0);
        for(let i = 0; i < 4; i++){
            const weight = $d5b85d29c0b78636$var$_skinWeight.getComponent(i);
            if (weight !== 0) {
                const boneIndex = $d5b85d29c0b78636$var$_skinIndex.getComponent(i);
                $d5b85d29c0b78636$var$_matrix4.multiplyMatrices(skeleton.bones[boneIndex].matrixWorld, skeleton.boneInverses[boneIndex]);
                vector.addScaledVector($d5b85d29c0b78636$var$_vector3.copy($d5b85d29c0b78636$var$_basePosition).applyMatrix4($d5b85d29c0b78636$var$_matrix4), weight);
            }
        }
        return vector.applyMatrix4(this.bindMatrixInverse);
    }
}
class $d5b85d29c0b78636$export$b127726e56765aa4 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(){
        super();
        this.isBone = true;
        this.type = 'Bone';
    }
}
class $d5b85d29c0b78636$export$b691f601014eabe1 extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(data = null, width = 1, height = 1, format, type, mapping, wrapS, wrapT, magFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0, minFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0, anisotropy, colorSpace){
        super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
        this.isDataTexture = true;
        this.image = {
            data: data,
            width: width,
            height: height
        };
        this.generateMipmaps = false;
        this.flipY = false;
        this.unpackAlignment = 1;
    }
}
const $d5b85d29c0b78636$var$_offsetMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_identityMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
class $d5b85d29c0b78636$export$8f31e4c4a37b8e9c {
    constructor(bones = [], boneInverses = []){
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.bones = bones.slice(0);
        this.boneInverses = boneInverses;
        this.boneMatrices = null;
        this.boneTexture = null;
        this.init();
    }
    init() {
        const bones = this.bones;
        const boneInverses = this.boneInverses;
        this.boneMatrices = new Float32Array(bones.length * 16);
        // calculate inverse bone matrices if necessary
        if (boneInverses.length === 0) this.calculateInverses();
        else // handle special case
        if (bones.length !== boneInverses.length) {
            console.warn('THREE.Skeleton: Number of inverse bone matrices does not match amount of bones.');
            this.boneInverses = [];
            for(let i = 0, il = this.bones.length; i < il; i++)this.boneInverses.push(new $d5b85d29c0b78636$export$2ae72fc923e5eb5());
        }
    }
    calculateInverses() {
        this.boneInverses.length = 0;
        for(let i = 0, il = this.bones.length; i < il; i++){
            const inverse = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
            if (this.bones[i]) inverse.copy(this.bones[i].matrixWorld).invert();
            this.boneInverses.push(inverse);
        }
    }
    pose() {
        // recover the bind-time world matrices
        for(let i = 0, il = this.bones.length; i < il; i++){
            const bone = this.bones[i];
            if (bone) bone.matrixWorld.copy(this.boneInverses[i]).invert();
        }
        // compute the local matrices, positions, rotations and scales
        for(let i = 0, il = this.bones.length; i < il; i++){
            const bone = this.bones[i];
            if (bone) {
                if (bone.parent && bone.parent.isBone) {
                    bone.matrix.copy(bone.parent.matrixWorld).invert();
                    bone.matrix.multiply(bone.matrixWorld);
                } else bone.matrix.copy(bone.matrixWorld);
                bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
            }
        }
    }
    update() {
        const bones = this.bones;
        const boneInverses = this.boneInverses;
        const boneMatrices = this.boneMatrices;
        const boneTexture = this.boneTexture;
        // flatten bone matrices to array
        for(let i = 0, il = bones.length; i < il; i++){
            // compute the offset between the current and the original transform
            const matrix = bones[i] ? bones[i].matrixWorld : $d5b85d29c0b78636$var$_identityMatrix;
            $d5b85d29c0b78636$var$_offsetMatrix.multiplyMatrices(matrix, boneInverses[i]);
            $d5b85d29c0b78636$var$_offsetMatrix.toArray(boneMatrices, i * 16);
        }
        if (boneTexture !== null) boneTexture.needsUpdate = true;
    }
    clone() {
        return new $d5b85d29c0b78636$export$8f31e4c4a37b8e9c(this.bones, this.boneInverses);
    }
    computeBoneTexture() {
        // layout (1 matrix = 4 pixels)
        //      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
        //  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)
        //       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)
        //       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)
        //       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)
        let size = Math.sqrt(this.bones.length * 4); // 4 pixels needed for 1 matrix
        size = Math.ceil(size / 4) * 4;
        size = Math.max(size, 4);
        const boneMatrices = new Float32Array(size * size * 4); // 4 floats per RGBA pixel
        boneMatrices.set(this.boneMatrices); // copy current values
        const boneTexture = new $d5b85d29c0b78636$export$b691f601014eabe1(boneMatrices, size, size, $d5b85d29c0b78636$export$3f8bb04b555a363c, $d5b85d29c0b78636$export$f6d331659b644596);
        boneTexture.needsUpdate = true;
        this.boneMatrices = boneMatrices;
        this.boneTexture = boneTexture;
        return this;
    }
    getBoneByName(name) {
        for(let i = 0, il = this.bones.length; i < il; i++){
            const bone = this.bones[i];
            if (bone.name === name) return bone;
        }
        return undefined;
    }
    dispose() {
        if (this.boneTexture !== null) {
            this.boneTexture.dispose();
            this.boneTexture = null;
        }
    }
    fromJSON(json, bones) {
        this.uuid = json.uuid;
        for(let i = 0, l = json.bones.length; i < l; i++){
            const uuid = json.bones[i];
            let bone = bones[uuid];
            if (bone === undefined) {
                console.warn('THREE.Skeleton: No bone found with UUID:', uuid);
                bone = new $d5b85d29c0b78636$export$b127726e56765aa4();
            }
            this.bones.push(bone);
            this.boneInverses.push(new $d5b85d29c0b78636$export$2ae72fc923e5eb5().fromArray(json.boneInverses[i]));
        }
        this.init();
        return this;
    }
    toJSON() {
        const data = {
            metadata: {
                version: 4.6,
                type: 'Skeleton',
                generator: 'Skeleton.toJSON'
            },
            bones: [],
            boneInverses: []
        };
        data.uuid = this.uuid;
        const bones = this.bones;
        const boneInverses = this.boneInverses;
        for(let i = 0, l = bones.length; i < l; i++){
            const bone = bones[i];
            data.bones.push(bone.uuid);
            const boneInverse = boneInverses[i];
            data.boneInverses.push(boneInverse.toArray());
        }
        return data;
    }
}
class $d5b85d29c0b78636$export$32ea87a8b54d744a extends $d5b85d29c0b78636$export$8dea267bd6bde117 {
    constructor(array, itemSize, normalized, meshPerAttribute = 1){
        super(array, itemSize, normalized);
        this.isInstancedBufferAttribute = true;
        this.meshPerAttribute = meshPerAttribute;
    }
    copy(source) {
        super.copy(source);
        this.meshPerAttribute = source.meshPerAttribute;
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.meshPerAttribute = this.meshPerAttribute;
        data.isInstancedBufferAttribute = true;
        return data;
    }
}
const $d5b85d29c0b78636$var$_instanceLocalMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_instanceWorldMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_instanceIntersects = [];
const $d5b85d29c0b78636$var$_box3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
const $d5b85d29c0b78636$var$_identity = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_mesh$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$e176487c05830cc5();
const $d5b85d29c0b78636$var$_sphere$4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
class $d5b85d29c0b78636$export$f3c979c331175ad7 extends $d5b85d29c0b78636$export$e176487c05830cc5 {
    constructor(geometry, material, count){
        super(geometry, material);
        this.isInstancedMesh = true;
        this.instanceMatrix = new $d5b85d29c0b78636$export$32ea87a8b54d744a(new Float32Array(count * 16), 16);
        this.instanceColor = null;
        this.morphTexture = null;
        this.count = count;
        this.boundingBox = null;
        this.boundingSphere = null;
        for(let i = 0; i < count; i++)this.setMatrixAt(i, $d5b85d29c0b78636$var$_identity);
    }
    computeBoundingBox() {
        const geometry = this.geometry;
        const count = this.count;
        if (this.boundingBox === null) this.boundingBox = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
        if (geometry.boundingBox === null) geometry.computeBoundingBox();
        this.boundingBox.makeEmpty();
        for(let i = 0; i < count; i++){
            this.getMatrixAt(i, $d5b85d29c0b78636$var$_instanceLocalMatrix);
            $d5b85d29c0b78636$var$_box3.copy(geometry.boundingBox).applyMatrix4($d5b85d29c0b78636$var$_instanceLocalMatrix);
            this.boundingBox.union($d5b85d29c0b78636$var$_box3);
        }
    }
    computeBoundingSphere() {
        const geometry = this.geometry;
        const count = this.count;
        if (this.boundingSphere === null) this.boundingSphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
        this.boundingSphere.makeEmpty();
        for(let i = 0; i < count; i++){
            this.getMatrixAt(i, $d5b85d29c0b78636$var$_instanceLocalMatrix);
            $d5b85d29c0b78636$var$_sphere$4.copy(geometry.boundingSphere).applyMatrix4($d5b85d29c0b78636$var$_instanceLocalMatrix);
            this.boundingSphere.union($d5b85d29c0b78636$var$_sphere$4);
        }
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.instanceMatrix.copy(source.instanceMatrix);
        if (source.morphTexture !== null) this.morphTexture = source.morphTexture.clone();
        if (source.instanceColor !== null) this.instanceColor = source.instanceColor.clone();
        this.count = source.count;
        if (source.boundingBox !== null) this.boundingBox = source.boundingBox.clone();
        if (source.boundingSphere !== null) this.boundingSphere = source.boundingSphere.clone();
        return this;
    }
    getColorAt(index, color) {
        color.fromArray(this.instanceColor.array, index * 3);
    }
    getMatrixAt(index, matrix) {
        matrix.fromArray(this.instanceMatrix.array, index * 16);
    }
    getMorphAt(index, object) {
        const objectInfluences = object.morphTargetInfluences;
        const array = this.morphTexture.source.data.data;
        const len = objectInfluences.length + 1; // All influences + the baseInfluenceSum
        const dataIndex = index * len + 1; // Skip the baseInfluenceSum at the beginning
        for(let i = 0; i < objectInfluences.length; i++)objectInfluences[i] = array[dataIndex + i];
    }
    raycast(raycaster, intersects) {
        const matrixWorld = this.matrixWorld;
        const raycastTimes = this.count;
        $d5b85d29c0b78636$var$_mesh$1.geometry = this.geometry;
        $d5b85d29c0b78636$var$_mesh$1.material = this.material;
        if ($d5b85d29c0b78636$var$_mesh$1.material === undefined) return;
        // test with bounding sphere first
        if (this.boundingSphere === null) this.computeBoundingSphere();
        $d5b85d29c0b78636$var$_sphere$4.copy(this.boundingSphere);
        $d5b85d29c0b78636$var$_sphere$4.applyMatrix4(matrixWorld);
        if (raycaster.ray.intersectsSphere($d5b85d29c0b78636$var$_sphere$4) === false) return;
        // now test each instance
        for(let instanceId = 0; instanceId < raycastTimes; instanceId++){
            // calculate the world matrix for each instance
            this.getMatrixAt(instanceId, $d5b85d29c0b78636$var$_instanceLocalMatrix);
            $d5b85d29c0b78636$var$_instanceWorldMatrix.multiplyMatrices(matrixWorld, $d5b85d29c0b78636$var$_instanceLocalMatrix);
            // the mesh represents this single instance
            $d5b85d29c0b78636$var$_mesh$1.matrixWorld = $d5b85d29c0b78636$var$_instanceWorldMatrix;
            $d5b85d29c0b78636$var$_mesh$1.raycast(raycaster, $d5b85d29c0b78636$var$_instanceIntersects);
            // process the result of raycast
            for(let i = 0, l = $d5b85d29c0b78636$var$_instanceIntersects.length; i < l; i++){
                const intersect = $d5b85d29c0b78636$var$_instanceIntersects[i];
                intersect.instanceId = instanceId;
                intersect.object = this;
                intersects.push(intersect);
            }
            $d5b85d29c0b78636$var$_instanceIntersects.length = 0;
        }
    }
    setColorAt(index, color) {
        if (this.instanceColor === null) this.instanceColor = new $d5b85d29c0b78636$export$32ea87a8b54d744a(new Float32Array(this.instanceMatrix.count * 3).fill(1), 3);
        color.toArray(this.instanceColor.array, index * 3);
    }
    setMatrixAt(index, matrix) {
        matrix.toArray(this.instanceMatrix.array, index * 16);
    }
    setMorphAt(index, object) {
        const objectInfluences = object.morphTargetInfluences;
        const len = objectInfluences.length + 1; // morphBaseInfluence + all influences
        if (this.morphTexture === null) this.morphTexture = new $d5b85d29c0b78636$export$b691f601014eabe1(new Float32Array(len * this.count), len, this.count, $d5b85d29c0b78636$export$4e041a7967d15c4b, $d5b85d29c0b78636$export$f6d331659b644596);
        const array = this.morphTexture.source.data.data;
        let morphInfluencesSum = 0;
        for(let i = 0; i < objectInfluences.length; i++)morphInfluencesSum += objectInfluences[i];
        const morphBaseInfluence = this.geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;
        const dataIndex = len * index;
        array[dataIndex] = morphBaseInfluence;
        array.set(objectInfluences, dataIndex + 1);
    }
    updateMorphTargets() {}
    dispose() {
        this.dispatchEvent({
            type: 'dispose'
        });
        if (this.morphTexture !== null) {
            this.morphTexture.dispose();
            this.morphTexture = null;
        }
        return this;
    }
}
const $d5b85d29c0b78636$var$_vector1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vector2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_normalMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$8ff26dafa08918();
class $d5b85d29c0b78636$export$7ff5ac152ef991b0 {
    constructor(normal = new $d5b85d29c0b78636$export$64b5c384219d3699(1, 0, 0), constant = 0){
        this.isPlane = true;
        // normal is assumed to be normalized
        this.normal = normal;
        this.constant = constant;
    }
    set(normal, constant) {
        this.normal.copy(normal);
        this.constant = constant;
        return this;
    }
    setComponents(x, y, z, w) {
        this.normal.set(x, y, z);
        this.constant = w;
        return this;
    }
    setFromNormalAndCoplanarPoint(normal, point) {
        this.normal.copy(normal);
        this.constant = -point.dot(this.normal);
        return this;
    }
    setFromCoplanarPoints(a, b, c) {
        const normal = $d5b85d29c0b78636$var$_vector1.subVectors(c, b).cross($d5b85d29c0b78636$var$_vector2.subVectors(a, b)).normalize();
        // Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
        this.setFromNormalAndCoplanarPoint(normal, a);
        return this;
    }
    copy(plane) {
        this.normal.copy(plane.normal);
        this.constant = plane.constant;
        return this;
    }
    normalize() {
        // Note: will lead to a divide by zero if the plane is invalid.
        const inverseNormalLength = 1.0 / this.normal.length();
        this.normal.multiplyScalar(inverseNormalLength);
        this.constant *= inverseNormalLength;
        return this;
    }
    negate() {
        this.constant *= -1;
        this.normal.negate();
        return this;
    }
    distanceToPoint(point) {
        return this.normal.dot(point) + this.constant;
    }
    distanceToSphere(sphere) {
        return this.distanceToPoint(sphere.center) - sphere.radius;
    }
    projectPoint(point, target) {
        return target.copy(point).addScaledVector(this.normal, -this.distanceToPoint(point));
    }
    intersectLine(line, target) {
        const direction = line.delta($d5b85d29c0b78636$var$_vector1);
        const denominator = this.normal.dot(direction);
        if (denominator === 0) {
            // line is coplanar, return origin
            if (this.distanceToPoint(line.start) === 0) return target.copy(line.start);
            // Unsure if this is the correct method to handle this case.
            return null;
        }
        const t = -(line.start.dot(this.normal) + this.constant) / denominator;
        if (t < 0 || t > 1) return null;
        return target.copy(line.start).addScaledVector(direction, t);
    }
    intersectsLine(line) {
        // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
        const startSign = this.distanceToPoint(line.start);
        const endSign = this.distanceToPoint(line.end);
        return startSign < 0 && endSign > 0 || endSign < 0 && startSign > 0;
    }
    intersectsBox(box) {
        return box.intersectsPlane(this);
    }
    intersectsSphere(sphere) {
        return sphere.intersectsPlane(this);
    }
    coplanarPoint(target) {
        return target.copy(this.normal).multiplyScalar(-this.constant);
    }
    applyMatrix4(matrix, optionalNormalMatrix) {
        const normalMatrix = optionalNormalMatrix || $d5b85d29c0b78636$var$_normalMatrix.getNormalMatrix(matrix);
        const referencePoint = this.coplanarPoint($d5b85d29c0b78636$var$_vector1).applyMatrix4(matrix);
        const normal = this.normal.applyMatrix3(normalMatrix).normalize();
        this.constant = -referencePoint.dot(normal);
        return this;
    }
    translate(offset) {
        this.constant -= offset.dot(this.normal);
        return this;
    }
    equals(plane) {
        return plane.normal.equals(this.normal) && plane.constant === this.constant;
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
const $d5b85d29c0b78636$var$_sphere$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
const $d5b85d29c0b78636$var$_vector$6 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$35efe6f4c85463d2 {
    constructor(p0 = new $d5b85d29c0b78636$export$7ff5ac152ef991b0(), p1 = new $d5b85d29c0b78636$export$7ff5ac152ef991b0(), p2 = new $d5b85d29c0b78636$export$7ff5ac152ef991b0(), p3 = new $d5b85d29c0b78636$export$7ff5ac152ef991b0(), p4 = new $d5b85d29c0b78636$export$7ff5ac152ef991b0(), p5 = new $d5b85d29c0b78636$export$7ff5ac152ef991b0()){
        this.planes = [
            p0,
            p1,
            p2,
            p3,
            p4,
            p5
        ];
    }
    set(p0, p1, p2, p3, p4, p5) {
        const planes = this.planes;
        planes[0].copy(p0);
        planes[1].copy(p1);
        planes[2].copy(p2);
        planes[3].copy(p3);
        planes[4].copy(p4);
        planes[5].copy(p5);
        return this;
    }
    copy(frustum) {
        const planes = this.planes;
        for(let i = 0; i < 6; i++)planes[i].copy(frustum.planes[i]);
        return this;
    }
    setFromProjectionMatrix(m, coordinateSystem = $d5b85d29c0b78636$export$5a0e9190d10875d3) {
        const planes = this.planes;
        const me = m.elements;
        const me0 = me[0], me1 = me[1], me2 = me[2], me3 = me[3];
        const me4 = me[4], me5 = me[5], me6 = me[6], me7 = me[7];
        const me8 = me[8], me9 = me[9], me10 = me[10], me11 = me[11];
        const me12 = me[12], me13 = me[13], me14 = me[14], me15 = me[15];
        planes[0].setComponents(me3 - me0, me7 - me4, me11 - me8, me15 - me12).normalize();
        planes[1].setComponents(me3 + me0, me7 + me4, me11 + me8, me15 + me12).normalize();
        planes[2].setComponents(me3 + me1, me7 + me5, me11 + me9, me15 + me13).normalize();
        planes[3].setComponents(me3 - me1, me7 - me5, me11 - me9, me15 - me13).normalize();
        planes[4].setComponents(me3 - me2, me7 - me6, me11 - me10, me15 - me14).normalize();
        if (coordinateSystem === $d5b85d29c0b78636$export$5a0e9190d10875d3) planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize();
        else if (coordinateSystem === $d5b85d29c0b78636$export$cc83beedcb9be9ac) planes[5].setComponents(me2, me6, me10, me14).normalize();
        else throw new Error('THREE.Frustum.setFromProjectionMatrix(): Invalid coordinate system: ' + coordinateSystem);
        return this;
    }
    intersectsObject(object) {
        if (object.boundingSphere !== undefined) {
            if (object.boundingSphere === null) object.computeBoundingSphere();
            $d5b85d29c0b78636$var$_sphere$3.copy(object.boundingSphere).applyMatrix4(object.matrixWorld);
        } else {
            const geometry = object.geometry;
            if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
            $d5b85d29c0b78636$var$_sphere$3.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld);
        }
        return this.intersectsSphere($d5b85d29c0b78636$var$_sphere$3);
    }
    intersectsSprite(sprite) {
        $d5b85d29c0b78636$var$_sphere$3.center.set(0, 0, 0);
        $d5b85d29c0b78636$var$_sphere$3.radius = 0.7071067811865476;
        $d5b85d29c0b78636$var$_sphere$3.applyMatrix4(sprite.matrixWorld);
        return this.intersectsSphere($d5b85d29c0b78636$var$_sphere$3);
    }
    intersectsSphere(sphere) {
        const planes = this.planes;
        const center = sphere.center;
        const negRadius = -sphere.radius;
        for(let i = 0; i < 6; i++){
            const distance = planes[i].distanceToPoint(center);
            if (distance < negRadius) return false;
        }
        return true;
    }
    intersectsBox(box) {
        const planes = this.planes;
        for(let i = 0; i < 6; i++){
            const plane = planes[i];
            // corner at max distance
            $d5b85d29c0b78636$var$_vector$6.x = plane.normal.x > 0 ? box.max.x : box.min.x;
            $d5b85d29c0b78636$var$_vector$6.y = plane.normal.y > 0 ? box.max.y : box.min.y;
            $d5b85d29c0b78636$var$_vector$6.z = plane.normal.z > 0 ? box.max.z : box.min.z;
            if (plane.distanceToPoint($d5b85d29c0b78636$var$_vector$6) < 0) return false;
        }
        return true;
    }
    containsPoint(point) {
        const planes = this.planes;
        for(let i = 0; i < 6; i++){
            if (planes[i].distanceToPoint(point) < 0) return false;
        }
        return true;
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
function $d5b85d29c0b78636$var$ascIdSort(a, b) {
    return a - b;
}
function $d5b85d29c0b78636$var$sortOpaque(a, b) {
    return a.z - b.z;
}
function $d5b85d29c0b78636$var$sortTransparent(a, b) {
    return b.z - a.z;
}
class $d5b85d29c0b78636$var$MultiDrawRenderList {
    constructor(){
        this.index = 0;
        this.pool = [];
        this.list = [];
    }
    push(start, count, z, index) {
        const pool = this.pool;
        const list = this.list;
        if (this.index >= pool.length) pool.push({
            start: -1,
            count: -1,
            z: -1,
            index: -1
        });
        const item = pool[this.index];
        list.push(item);
        this.index++;
        item.start = start;
        item.count = count;
        item.z = z;
        item.index = index;
    }
    reset() {
        this.list.length = 0;
        this.index = 0;
    }
}
const $d5b85d29c0b78636$var$_matrix$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_whiteColor = /*@__PURE__*/ new $d5b85d29c0b78636$export$892596cec99bc70e(1, 1, 1);
const $d5b85d29c0b78636$var$_frustum = /*@__PURE__*/ new $d5b85d29c0b78636$export$35efe6f4c85463d2();
const $d5b85d29c0b78636$var$_box$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
const $d5b85d29c0b78636$var$_sphere$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
const $d5b85d29c0b78636$var$_vector$5 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_forward = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_temp = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_renderList = /*@__PURE__*/ new $d5b85d29c0b78636$var$MultiDrawRenderList();
const $d5b85d29c0b78636$var$_mesh = /*@__PURE__*/ new $d5b85d29c0b78636$export$e176487c05830cc5();
const $d5b85d29c0b78636$var$_batchIntersects = [];
// copies data from attribute "src" into "target" starting at "targetOffset"
function $d5b85d29c0b78636$var$copyAttributeData(src, target, targetOffset = 0) {
    const itemSize = target.itemSize;
    if (src.isInterleavedBufferAttribute || src.array.constructor !== target.array.constructor) {
        // use the component getters and setters if the array data cannot
        // be copied directly
        const vertexCount = src.count;
        for(let i = 0; i < vertexCount; i++)for(let c = 0; c < itemSize; c++)target.setComponent(i + targetOffset, c, src.getComponent(i, c));
    } else // faster copy approach using typed array set function
    target.array.set(src.array, targetOffset * itemSize);
    target.needsUpdate = true;
}
// safely copies array contents to a potentially smaller array
function $d5b85d29c0b78636$var$copyArrayContents(src, target) {
    if (src.constructor !== target.constructor) {
        // if arrays are of a different type (eg due to index size increasing) then data must be per-element copied
        const len = Math.min(src.length, target.length);
        for(let i = 0; i < len; i++)target[i] = src[i];
    } else {
        // if the arrays use the same data layout we can use a fast block copy
        const len = Math.min(src.length, target.length);
        target.set(new src.constructor(src.buffer, 0, len));
    }
}
class $d5b85d29c0b78636$export$6e01c5ee52ed8f7b extends $d5b85d29c0b78636$export$e176487c05830cc5 {
    get maxInstanceCount() {
        return this._maxInstanceCount;
    }
    get instanceCount() {
        return this._instanceInfo.length - this._availableInstanceIds.length;
    }
    get unusedVertexCount() {
        return this._maxVertexCount - this._nextVertexStart;
    }
    get unusedIndexCount() {
        return this._maxIndexCount - this._nextIndexStart;
    }
    constructor(maxInstanceCount, maxVertexCount, maxIndexCount = maxVertexCount * 2, material){
        super(new $d5b85d29c0b78636$export$b7be63a67df8959(), material);
        this.isBatchedMesh = true;
        this.perObjectFrustumCulled = true;
        this.sortObjects = true;
        this.boundingBox = null;
        this.boundingSphere = null;
        this.customSort = null;
        // stores visible, active, and geometry id per instance and reserved buffer ranges for geometries
        this._instanceInfo = [];
        this._geometryInfo = [];
        // instance, geometry ids that have been set as inactive, and are available to be overwritten
        this._availableInstanceIds = [];
        this._availableGeometryIds = [];
        // used to track where the next point is that geometry should be inserted
        this._nextIndexStart = 0;
        this._nextVertexStart = 0;
        this._geometryCount = 0;
        // flags
        this._visibilityChanged = true;
        this._geometryInitialized = false;
        // cached user options
        this._maxInstanceCount = maxInstanceCount;
        this._maxVertexCount = maxVertexCount;
        this._maxIndexCount = maxIndexCount;
        // buffers for multi draw
        this._multiDrawCounts = new Int32Array(maxInstanceCount);
        this._multiDrawStarts = new Int32Array(maxInstanceCount);
        this._multiDrawCount = 0;
        this._multiDrawInstances = null;
        // Local matrix per geometry by using data texture
        this._matricesTexture = null;
        this._indirectTexture = null;
        this._colorsTexture = null;
        this._initMatricesTexture();
        this._initIndirectTexture();
    }
    _initMatricesTexture() {
        // layout (1 matrix = 4 pixels)
        //      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
        //  with  8x8  pixel texture max   16 matrices * 4 pixels =  (8 * 8)
        //       16x16 pixel texture max   64 matrices * 4 pixels = (16 * 16)
        //       32x32 pixel texture max  256 matrices * 4 pixels = (32 * 32)
        //       64x64 pixel texture max 1024 matrices * 4 pixels = (64 * 64)
        let size = Math.sqrt(this._maxInstanceCount * 4); // 4 pixels needed for 1 matrix
        size = Math.ceil(size / 4) * 4;
        size = Math.max(size, 4);
        const matricesArray = new Float32Array(size * size * 4); // 4 floats per RGBA pixel
        const matricesTexture = new $d5b85d29c0b78636$export$b691f601014eabe1(matricesArray, size, size, $d5b85d29c0b78636$export$3f8bb04b555a363c, $d5b85d29c0b78636$export$f6d331659b644596);
        this._matricesTexture = matricesTexture;
    }
    _initIndirectTexture() {
        let size = Math.sqrt(this._maxInstanceCount);
        size = Math.ceil(size);
        const indirectArray = new Uint32Array(size * size);
        const indirectTexture = new $d5b85d29c0b78636$export$b691f601014eabe1(indirectArray, size, size, $d5b85d29c0b78636$export$aa92e870a709d190, $d5b85d29c0b78636$export$c3c7fc4518ebba96);
        this._indirectTexture = indirectTexture;
    }
    _initColorsTexture() {
        let size = Math.sqrt(this._maxInstanceCount);
        size = Math.ceil(size);
        // 4 floats per RGBA pixel initialized to white
        const colorsArray = new Float32Array(size * size * 4).fill(1);
        const colorsTexture = new $d5b85d29c0b78636$export$b691f601014eabe1(colorsArray, size, size, $d5b85d29c0b78636$export$3f8bb04b555a363c, $d5b85d29c0b78636$export$f6d331659b644596);
        colorsTexture.colorSpace = $d5b85d29c0b78636$export$5e6fd513f44698c.workingColorSpace;
        this._colorsTexture = colorsTexture;
    }
    _initializeGeometry(reference) {
        const geometry = this.geometry;
        const maxVertexCount = this._maxVertexCount;
        const maxIndexCount = this._maxIndexCount;
        if (this._geometryInitialized === false) {
            for(const attributeName in reference.attributes){
                const srcAttribute = reference.getAttribute(attributeName);
                const { array: array, itemSize: itemSize, normalized: normalized } = srcAttribute;
                const dstArray = new array.constructor(maxVertexCount * itemSize);
                const dstAttribute = new $d5b85d29c0b78636$export$8dea267bd6bde117(dstArray, itemSize, normalized);
                geometry.setAttribute(attributeName, dstAttribute);
            }
            if (reference.getIndex() !== null) {
                // Reserve last u16 index for primitive restart.
                const indexArray = maxVertexCount > 65535 ? new Uint32Array(maxIndexCount) : new Uint16Array(maxIndexCount);
                geometry.setIndex(new $d5b85d29c0b78636$export$8dea267bd6bde117(indexArray, 1));
            }
            this._geometryInitialized = true;
        }
    }
    // Make sure the geometry is compatible with the existing combined geometry attributes
    _validateGeometry(geometry) {
        // check to ensure the geometries are using consistent attributes and indices
        const batchGeometry = this.geometry;
        if (Boolean(geometry.getIndex()) !== Boolean(batchGeometry.getIndex())) throw new Error('THREE.BatchedMesh: All geometries must consistently have "index".');
        for(const attributeName in batchGeometry.attributes){
            if (!geometry.hasAttribute(attributeName)) throw new Error(`THREE.BatchedMesh: Added geometry missing "${attributeName}". All geometries must have consistent attributes.`);
            const srcAttribute = geometry.getAttribute(attributeName);
            const dstAttribute = batchGeometry.getAttribute(attributeName);
            if (srcAttribute.itemSize !== dstAttribute.itemSize || srcAttribute.normalized !== dstAttribute.normalized) throw new Error('THREE.BatchedMesh: All attributes must have a consistent itemSize and normalized value.');
        }
    }
    validateInstanceId(instanceId) {
        const instanceInfo = this._instanceInfo;
        if (instanceId < 0 || instanceId >= instanceInfo.length || instanceInfo[instanceId].active === false) throw new Error(`THREE.BatchedMesh: Invalid instanceId ${instanceId}. Instance is either out of range or has been deleted.`);
    }
    validateGeometryId(geometryId) {
        const geometryInfoList = this._geometryInfo;
        if (geometryId < 0 || geometryId >= geometryInfoList.length || geometryInfoList[geometryId].active === false) throw new Error(`THREE.BatchedMesh: Invalid geometryId ${geometryId}. Geometry is either out of range or has been deleted.`);
    }
    setCustomSort(func) {
        this.customSort = func;
        return this;
    }
    computeBoundingBox() {
        if (this.boundingBox === null) this.boundingBox = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
        const boundingBox = this.boundingBox;
        const instanceInfo = this._instanceInfo;
        boundingBox.makeEmpty();
        for(let i = 0, l = instanceInfo.length; i < l; i++){
            if (instanceInfo[i].active === false) continue;
            const geometryId = instanceInfo[i].geometryIndex;
            this.getMatrixAt(i, $d5b85d29c0b78636$var$_matrix$1);
            this.getBoundingBoxAt(geometryId, $d5b85d29c0b78636$var$_box$1).applyMatrix4($d5b85d29c0b78636$var$_matrix$1);
            boundingBox.union($d5b85d29c0b78636$var$_box$1);
        }
    }
    computeBoundingSphere() {
        if (this.boundingSphere === null) this.boundingSphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
        const boundingSphere = this.boundingSphere;
        const instanceInfo = this._instanceInfo;
        boundingSphere.makeEmpty();
        for(let i = 0, l = instanceInfo.length; i < l; i++){
            if (instanceInfo[i].active === false) continue;
            const geometryId = instanceInfo[i].geometryIndex;
            this.getMatrixAt(i, $d5b85d29c0b78636$var$_matrix$1);
            this.getBoundingSphereAt(geometryId, $d5b85d29c0b78636$var$_sphere$2).applyMatrix4($d5b85d29c0b78636$var$_matrix$1);
            boundingSphere.union($d5b85d29c0b78636$var$_sphere$2);
        }
    }
    addInstance(geometryId) {
        const atCapacity = this._instanceInfo.length >= this.maxInstanceCount;
        // ensure we're not over geometry
        if (atCapacity && this._availableInstanceIds.length === 0) throw new Error('THREE.BatchedMesh: Maximum item count reached.');
        const instanceInfo = {
            visible: true,
            active: true,
            geometryIndex: geometryId
        };
        let drawId = null;
        // Prioritize using previously freed instance ids
        if (this._availableInstanceIds.length > 0) {
            this._availableInstanceIds.sort($d5b85d29c0b78636$var$ascIdSort);
            drawId = this._availableInstanceIds.shift();
            this._instanceInfo[drawId] = instanceInfo;
        } else {
            drawId = this._instanceInfo.length;
            this._instanceInfo.push(instanceInfo);
        }
        const matricesTexture = this._matricesTexture;
        $d5b85d29c0b78636$var$_matrix$1.identity().toArray(matricesTexture.image.data, drawId * 16);
        matricesTexture.needsUpdate = true;
        const colorsTexture = this._colorsTexture;
        if (colorsTexture) {
            $d5b85d29c0b78636$var$_whiteColor.toArray(colorsTexture.image.data, drawId * 4);
            colorsTexture.needsUpdate = true;
        }
        this._visibilityChanged = true;
        return drawId;
    }
    addGeometry(geometry, reservedVertexCount = -1, reservedIndexCount = -1) {
        this._initializeGeometry(geometry);
        this._validateGeometry(geometry);
        const geometryInfo = {
            // geometry information
            vertexStart: -1,
            vertexCount: -1,
            reservedVertexCount: -1,
            indexStart: -1,
            indexCount: -1,
            reservedIndexCount: -1,
            // draw range information
            start: -1,
            count: -1,
            // state
            boundingBox: null,
            boundingSphere: null,
            active: true
        };
        const geometryInfoList = this._geometryInfo;
        geometryInfo.vertexStart = this._nextVertexStart;
        geometryInfo.reservedVertexCount = reservedVertexCount === -1 ? geometry.getAttribute('position').count : reservedVertexCount;
        const index = geometry.getIndex();
        const hasIndex = index !== null;
        if (hasIndex) {
            geometryInfo.indexStart = this._nextIndexStart;
            geometryInfo.reservedIndexCount = reservedIndexCount === -1 ? index.count : reservedIndexCount;
        }
        if (geometryInfo.indexStart !== -1 && geometryInfo.indexStart + geometryInfo.reservedIndexCount > this._maxIndexCount || geometryInfo.vertexStart + geometryInfo.reservedVertexCount > this._maxVertexCount) throw new Error('THREE.BatchedMesh: Reserved space request exceeds the maximum buffer size.');
        // update id
        let geometryId;
        if (this._availableGeometryIds.length > 0) {
            this._availableGeometryIds.sort($d5b85d29c0b78636$var$ascIdSort);
            geometryId = this._availableGeometryIds.shift();
            geometryInfoList[geometryId] = geometryInfo;
        } else {
            geometryId = this._geometryCount;
            this._geometryCount++;
            geometryInfoList.push(geometryInfo);
        }
        // update the geometry
        this.setGeometryAt(geometryId, geometry);
        // increment the next geometry position
        this._nextIndexStart = geometryInfo.indexStart + geometryInfo.reservedIndexCount;
        this._nextVertexStart = geometryInfo.vertexStart + geometryInfo.reservedVertexCount;
        return geometryId;
    }
    setGeometryAt(geometryId, geometry) {
        if (geometryId >= this._geometryCount) throw new Error('THREE.BatchedMesh: Maximum geometry count reached.');
        this._validateGeometry(geometry);
        const batchGeometry = this.geometry;
        const hasIndex = batchGeometry.getIndex() !== null;
        const dstIndex = batchGeometry.getIndex();
        const srcIndex = geometry.getIndex();
        const geometryInfo = this._geometryInfo[geometryId];
        if (hasIndex && srcIndex.count > geometryInfo.reservedIndexCount || geometry.attributes.position.count > geometryInfo.reservedVertexCount) throw new Error('THREE.BatchedMesh: Reserved space not large enough for provided geometry.');
        // copy geometry buffer data over
        const vertexStart = geometryInfo.vertexStart;
        const reservedVertexCount = geometryInfo.reservedVertexCount;
        geometryInfo.vertexCount = geometry.getAttribute('position').count;
        for(const attributeName in batchGeometry.attributes){
            // copy attribute data
            const srcAttribute = geometry.getAttribute(attributeName);
            const dstAttribute = batchGeometry.getAttribute(attributeName);
            $d5b85d29c0b78636$var$copyAttributeData(srcAttribute, dstAttribute, vertexStart);
            // fill the rest in with zeroes
            const itemSize = srcAttribute.itemSize;
            for(let i = srcAttribute.count, l = reservedVertexCount; i < l; i++){
                const index = vertexStart + i;
                for(let c = 0; c < itemSize; c++)dstAttribute.setComponent(index, c, 0);
            }
            dstAttribute.needsUpdate = true;
            dstAttribute.addUpdateRange(vertexStart * itemSize, reservedVertexCount * itemSize);
        }
        // copy index
        if (hasIndex) {
            const indexStart = geometryInfo.indexStart;
            const reservedIndexCount = geometryInfo.reservedIndexCount;
            geometryInfo.indexCount = geometry.getIndex().count;
            // copy index data over
            for(let i = 0; i < srcIndex.count; i++)dstIndex.setX(indexStart + i, vertexStart + srcIndex.getX(i));
            // fill the rest in with zeroes
            for(let i = srcIndex.count, l = reservedIndexCount; i < l; i++)dstIndex.setX(indexStart + i, vertexStart);
            dstIndex.needsUpdate = true;
            dstIndex.addUpdateRange(indexStart, geometryInfo.reservedIndexCount);
        }
        // update the draw range
        geometryInfo.start = hasIndex ? geometryInfo.indexStart : geometryInfo.vertexStart;
        geometryInfo.count = hasIndex ? geometryInfo.indexCount : geometryInfo.vertexCount;
        // store the bounding boxes
        geometryInfo.boundingBox = null;
        if (geometry.boundingBox !== null) geometryInfo.boundingBox = geometry.boundingBox.clone();
        geometryInfo.boundingSphere = null;
        if (geometry.boundingSphere !== null) geometryInfo.boundingSphere = geometry.boundingSphere.clone();
        this._visibilityChanged = true;
        return geometryId;
    }
    deleteGeometry(geometryId) {
        const geometryInfoList = this._geometryInfo;
        if (geometryId >= geometryInfoList.length || geometryInfoList[geometryId].active === false) return this;
        // delete any instances associated with this geometry
        const instanceInfo = this._instanceInfo;
        for(let i = 0, l = instanceInfo.length; i < l; i++)if (instanceInfo[i].geometryIndex === geometryId) this.deleteInstance(i);
        geometryInfoList[geometryId].active = false;
        this._availableGeometryIds.push(geometryId);
        this._visibilityChanged = true;
        return this;
    }
    deleteInstance(instanceId) {
        this.validateInstanceId(instanceId);
        this._instanceInfo[instanceId].active = false;
        this._availableInstanceIds.push(instanceId);
        this._visibilityChanged = true;
        return this;
    }
    optimize() {
        // track the next indices to copy data to
        let nextVertexStart = 0;
        let nextIndexStart = 0;
        // Iterate over all geometry ranges in order sorted from earliest in the geometry buffer to latest
        // in the geometry buffer. Because draw range objects can be reused there is no guarantee of their order.
        const geometryInfoList = this._geometryInfo;
        const indices = geometryInfoList.map((e, i)=>i).sort((a, b)=>{
            return geometryInfoList[a].vertexStart - geometryInfoList[b].vertexStart;
        });
        const geometry = this.geometry;
        for(let i = 0, l = geometryInfoList.length; i < l; i++){
            // if a geometry range is inactive then don't copy anything
            const index = indices[i];
            const geometryInfo = geometryInfoList[index];
            if (geometryInfo.active === false) continue;
            // if a geometry contains an index buffer then shift it, as well
            if (geometry.index !== null) {
                if (geometryInfo.indexStart !== nextIndexStart) {
                    const { indexStart: indexStart, vertexStart: vertexStart, reservedIndexCount: reservedIndexCount } = geometryInfo;
                    const index = geometry.index;
                    const array = index.array;
                    // shift the index pointers based on how the vertex data will shift
                    // adjusting the index must happen first so the original vertex start value is available
                    const elementDelta = nextVertexStart - vertexStart;
                    for(let j = indexStart; j < indexStart + reservedIndexCount; j++)array[j] = array[j] + elementDelta;
                    index.array.copyWithin(nextIndexStart, indexStart, indexStart + reservedIndexCount);
                    index.addUpdateRange(nextIndexStart, reservedIndexCount);
                    geometryInfo.indexStart = nextIndexStart;
                }
                nextIndexStart += geometryInfo.reservedIndexCount;
            }
            // if a geometry needs to be moved then copy attribute data to overwrite unused space
            if (geometryInfo.vertexStart !== nextVertexStart) {
                const { vertexStart: vertexStart, reservedVertexCount: reservedVertexCount } = geometryInfo;
                const attributes = geometry.attributes;
                for(const key in attributes){
                    const attribute = attributes[key];
                    const { array: array, itemSize: itemSize } = attribute;
                    array.copyWithin(nextVertexStart * itemSize, vertexStart * itemSize, (vertexStart + reservedVertexCount) * itemSize);
                    attribute.addUpdateRange(nextVertexStart * itemSize, reservedVertexCount * itemSize);
                }
                geometryInfo.vertexStart = nextVertexStart;
            }
            nextVertexStart += geometryInfo.reservedVertexCount;
            geometryInfo.start = geometry.index ? geometryInfo.indexStart : geometryInfo.vertexStart;
            // step the next geometry points to the shifted position
            this._nextIndexStart = geometry.index ? geometryInfo.indexStart + geometryInfo.reservedIndexCount : 0;
            this._nextVertexStart = geometryInfo.vertexStart + geometryInfo.reservedVertexCount;
        }
        return this;
    }
    // get bounding box and compute it if it doesn't exist
    getBoundingBoxAt(geometryId, target) {
        if (geometryId >= this._geometryCount) return null;
        // compute bounding box
        const geometry = this.geometry;
        const geometryInfo = this._geometryInfo[geometryId];
        if (geometryInfo.boundingBox === null) {
            const box = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
            const index = geometry.index;
            const position = geometry.attributes.position;
            for(let i = geometryInfo.start, l = geometryInfo.start + geometryInfo.count; i < l; i++){
                let iv = i;
                if (index) iv = index.getX(iv);
                box.expandByPoint($d5b85d29c0b78636$var$_vector$5.fromBufferAttribute(position, iv));
            }
            geometryInfo.boundingBox = box;
        }
        target.copy(geometryInfo.boundingBox);
        return target;
    }
    // get bounding sphere and compute it if it doesn't exist
    getBoundingSphereAt(geometryId, target) {
        if (geometryId >= this._geometryCount) return null;
        // compute bounding sphere
        const geometry = this.geometry;
        const geometryInfo = this._geometryInfo[geometryId];
        if (geometryInfo.boundingSphere === null) {
            const sphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
            this.getBoundingBoxAt(geometryId, $d5b85d29c0b78636$var$_box$1);
            $d5b85d29c0b78636$var$_box$1.getCenter(sphere.center);
            const index = geometry.index;
            const position = geometry.attributes.position;
            let maxRadiusSq = 0;
            for(let i = geometryInfo.start, l = geometryInfo.start + geometryInfo.count; i < l; i++){
                let iv = i;
                if (index) iv = index.getX(iv);
                $d5b85d29c0b78636$var$_vector$5.fromBufferAttribute(position, iv);
                maxRadiusSq = Math.max(maxRadiusSq, sphere.center.distanceToSquared($d5b85d29c0b78636$var$_vector$5));
            }
            sphere.radius = Math.sqrt(maxRadiusSq);
            geometryInfo.boundingSphere = sphere;
        }
        target.copy(geometryInfo.boundingSphere);
        return target;
    }
    setMatrixAt(instanceId, matrix) {
        this.validateInstanceId(instanceId);
        const matricesTexture = this._matricesTexture;
        const matricesArray = this._matricesTexture.image.data;
        matrix.toArray(matricesArray, instanceId * 16);
        matricesTexture.needsUpdate = true;
        return this;
    }
    getMatrixAt(instanceId, matrix) {
        this.validateInstanceId(instanceId);
        return matrix.fromArray(this._matricesTexture.image.data, instanceId * 16);
    }
    setColorAt(instanceId, color) {
        this.validateInstanceId(instanceId);
        if (this._colorsTexture === null) this._initColorsTexture();
        color.toArray(this._colorsTexture.image.data, instanceId * 4);
        this._colorsTexture.needsUpdate = true;
        return this;
    }
    getColorAt(instanceId, color) {
        this.validateInstanceId(instanceId);
        return color.fromArray(this._colorsTexture.image.data, instanceId * 4);
    }
    setVisibleAt(instanceId, value) {
        this.validateInstanceId(instanceId);
        if (this._instanceInfo[instanceId].visible === value) return this;
        this._instanceInfo[instanceId].visible = value;
        this._visibilityChanged = true;
        return this;
    }
    getVisibleAt(instanceId) {
        this.validateInstanceId(instanceId);
        return this._instanceInfo[instanceId].visible;
    }
    setGeometryIdAt(instanceId, geometryId) {
        this.validateInstanceId(instanceId);
        this.validateGeometryId(geometryId);
        this._instanceInfo[instanceId].geometryIndex = geometryId;
        return this;
    }
    getGeometryIdAt(instanceId) {
        this.validateInstanceId(instanceId);
        return this._instanceInfo[instanceId].geometryIndex;
    }
    getGeometryRangeAt(geometryId, target = {}) {
        this.validateGeometryId(geometryId);
        const geometryInfo = this._geometryInfo[geometryId];
        target.vertexStart = geometryInfo.vertexStart;
        target.vertexCount = geometryInfo.vertexCount;
        target.reservedVertexCount = geometryInfo.reservedVertexCount;
        target.indexStart = geometryInfo.indexStart;
        target.indexCount = geometryInfo.indexCount;
        target.reservedIndexCount = geometryInfo.reservedIndexCount;
        target.start = geometryInfo.start;
        target.count = geometryInfo.count;
        return target;
    }
    setInstanceCount(maxInstanceCount) {
        // shrink the available instances as much as possible
        const availableInstanceIds = this._availableInstanceIds;
        const instanceInfo = this._instanceInfo;
        availableInstanceIds.sort($d5b85d29c0b78636$var$ascIdSort);
        while(availableInstanceIds[availableInstanceIds.length - 1] === instanceInfo.length){
            instanceInfo.pop();
            availableInstanceIds.pop();
        }
        // throw an error if it can't be shrunk to the desired size
        if (maxInstanceCount < instanceInfo.length) throw new Error(`BatchedMesh: Instance ids outside the range ${maxInstanceCount} are being used. Cannot shrink instance count.`);
        // copy the multi draw counts
        const multiDrawCounts = new Int32Array(maxInstanceCount);
        const multiDrawStarts = new Int32Array(maxInstanceCount);
        $d5b85d29c0b78636$var$copyArrayContents(this._multiDrawCounts, multiDrawCounts);
        $d5b85d29c0b78636$var$copyArrayContents(this._multiDrawStarts, multiDrawStarts);
        this._multiDrawCounts = multiDrawCounts;
        this._multiDrawStarts = multiDrawStarts;
        this._maxInstanceCount = maxInstanceCount;
        // update texture data for instance sampling
        const indirectTexture = this._indirectTexture;
        const matricesTexture = this._matricesTexture;
        const colorsTexture = this._colorsTexture;
        indirectTexture.dispose();
        this._initIndirectTexture();
        $d5b85d29c0b78636$var$copyArrayContents(indirectTexture.image.data, this._indirectTexture.image.data);
        matricesTexture.dispose();
        this._initMatricesTexture();
        $d5b85d29c0b78636$var$copyArrayContents(matricesTexture.image.data, this._matricesTexture.image.data);
        if (colorsTexture) {
            colorsTexture.dispose();
            this._initColorsTexture();
            $d5b85d29c0b78636$var$copyArrayContents(colorsTexture.image.data, this._colorsTexture.image.data);
        }
    }
    setGeometrySize(maxVertexCount, maxIndexCount) {
        // Check if we can shrink to the requested vertex attribute size
        const validRanges = [
            ...this._geometryInfo
        ].filter((info)=>info.active);
        const requiredVertexLength = Math.max(...validRanges.map((range)=>range.vertexStart + range.reservedVertexCount));
        if (requiredVertexLength > maxVertexCount) throw new Error(`BatchedMesh: Geometry vertex values are being used outside the range ${maxIndexCount}. Cannot shrink further.`);
        // Check if we can shrink to the requested index attribute size
        if (this.geometry.index) {
            const requiredIndexLength = Math.max(...validRanges.map((range)=>range.indexStart + range.reservedIndexCount));
            if (requiredIndexLength > maxIndexCount) throw new Error(`BatchedMesh: Geometry index values are being used outside the range ${maxIndexCount}. Cannot shrink further.`);
        }
        //
        // dispose of the previous geometry
        const oldGeometry = this.geometry;
        oldGeometry.dispose();
        // recreate the geometry needed based on the previous variant
        this._maxVertexCount = maxVertexCount;
        this._maxIndexCount = maxIndexCount;
        if (this._geometryInitialized) {
            this._geometryInitialized = false;
            this.geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
            this._initializeGeometry(oldGeometry);
        }
        // copy data from the previous geometry
        const geometry = this.geometry;
        if (oldGeometry.index) $d5b85d29c0b78636$var$copyArrayContents(oldGeometry.index.array, geometry.index.array);
        for(const key in oldGeometry.attributes)$d5b85d29c0b78636$var$copyArrayContents(oldGeometry.attributes[key].array, geometry.attributes[key].array);
    }
    raycast(raycaster, intersects) {
        const instanceInfo = this._instanceInfo;
        const geometryInfoList = this._geometryInfo;
        const matrixWorld = this.matrixWorld;
        const batchGeometry = this.geometry;
        // iterate over each geometry
        $d5b85d29c0b78636$var$_mesh.material = this.material;
        $d5b85d29c0b78636$var$_mesh.geometry.index = batchGeometry.index;
        $d5b85d29c0b78636$var$_mesh.geometry.attributes = batchGeometry.attributes;
        if ($d5b85d29c0b78636$var$_mesh.geometry.boundingBox === null) $d5b85d29c0b78636$var$_mesh.geometry.boundingBox = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
        if ($d5b85d29c0b78636$var$_mesh.geometry.boundingSphere === null) $d5b85d29c0b78636$var$_mesh.geometry.boundingSphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
        for(let i = 0, l = instanceInfo.length; i < l; i++){
            if (!instanceInfo[i].visible || !instanceInfo[i].active) continue;
            const geometryId = instanceInfo[i].geometryIndex;
            const geometryInfo = geometryInfoList[geometryId];
            $d5b85d29c0b78636$var$_mesh.geometry.setDrawRange(geometryInfo.start, geometryInfo.count);
            // get the intersects
            this.getMatrixAt(i, $d5b85d29c0b78636$var$_mesh.matrixWorld).premultiply(matrixWorld);
            this.getBoundingBoxAt(geometryId, $d5b85d29c0b78636$var$_mesh.geometry.boundingBox);
            this.getBoundingSphereAt(geometryId, $d5b85d29c0b78636$var$_mesh.geometry.boundingSphere);
            $d5b85d29c0b78636$var$_mesh.raycast(raycaster, $d5b85d29c0b78636$var$_batchIntersects);
            // add batch id to the intersects
            for(let j = 0, l = $d5b85d29c0b78636$var$_batchIntersects.length; j < l; j++){
                const intersect = $d5b85d29c0b78636$var$_batchIntersects[j];
                intersect.object = this;
                intersect.batchId = i;
                intersects.push(intersect);
            }
            $d5b85d29c0b78636$var$_batchIntersects.length = 0;
        }
        $d5b85d29c0b78636$var$_mesh.material = null;
        $d5b85d29c0b78636$var$_mesh.geometry.index = null;
        $d5b85d29c0b78636$var$_mesh.geometry.attributes = {};
        $d5b85d29c0b78636$var$_mesh.geometry.setDrawRange(0, Infinity);
    }
    copy(source) {
        super.copy(source);
        this.geometry = source.geometry.clone();
        this.perObjectFrustumCulled = source.perObjectFrustumCulled;
        this.sortObjects = source.sortObjects;
        this.boundingBox = source.boundingBox !== null ? source.boundingBox.clone() : null;
        this.boundingSphere = source.boundingSphere !== null ? source.boundingSphere.clone() : null;
        this._geometryInfo = source._geometryInfo.map((info)=>({
                ...info,
                boundingBox: info.boundingBox !== null ? info.boundingBox.clone() : null,
                boundingSphere: info.boundingSphere !== null ? info.boundingSphere.clone() : null
            }));
        this._instanceInfo = source._instanceInfo.map((info)=>({
                ...info
            }));
        this._maxInstanceCount = source._maxInstanceCount;
        this._maxVertexCount = source._maxVertexCount;
        this._maxIndexCount = source._maxIndexCount;
        this._geometryInitialized = source._geometryInitialized;
        this._geometryCount = source._geometryCount;
        this._multiDrawCounts = source._multiDrawCounts.slice();
        this._multiDrawStarts = source._multiDrawStarts.slice();
        this._matricesTexture = source._matricesTexture.clone();
        this._matricesTexture.image.data = this._matricesTexture.image.data.slice();
        if (this._colorsTexture !== null) {
            this._colorsTexture = source._colorsTexture.clone();
            this._colorsTexture.image.data = this._colorsTexture.image.data.slice();
        }
        return this;
    }
    dispose() {
        // Assuming the geometry is not shared with other meshes
        this.geometry.dispose();
        this._matricesTexture.dispose();
        this._matricesTexture = null;
        this._indirectTexture.dispose();
        this._indirectTexture = null;
        if (this._colorsTexture !== null) {
            this._colorsTexture.dispose();
            this._colorsTexture = null;
        }
        return this;
    }
    onBeforeRender(renderer, scene, camera, geometry, material /*, _group*/ ) {
        // if visibility has not changed and frustum culling and object sorting is not required
        // then skip iterating over all items
        if (!this._visibilityChanged && !this.perObjectFrustumCulled && !this.sortObjects) return;
        // the indexed version of the multi draw function requires specifying the start
        // offset in bytes.
        const index = geometry.getIndex();
        const bytesPerElement = index === null ? 1 : index.array.BYTES_PER_ELEMENT;
        const instanceInfo = this._instanceInfo;
        const multiDrawStarts = this._multiDrawStarts;
        const multiDrawCounts = this._multiDrawCounts;
        const geometryInfoList = this._geometryInfo;
        const perObjectFrustumCulled = this.perObjectFrustumCulled;
        const indirectTexture = this._indirectTexture;
        const indirectArray = indirectTexture.image.data;
        // prepare the frustum in the local frame
        if (perObjectFrustumCulled) {
            $d5b85d29c0b78636$var$_matrix$1.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse).multiply(this.matrixWorld);
            $d5b85d29c0b78636$var$_frustum.setFromProjectionMatrix($d5b85d29c0b78636$var$_matrix$1, renderer.coordinateSystem);
        }
        let multiDrawCount = 0;
        if (this.sortObjects) {
            // get the camera position in the local frame
            $d5b85d29c0b78636$var$_matrix$1.copy(this.matrixWorld).invert();
            $d5b85d29c0b78636$var$_vector$5.setFromMatrixPosition(camera.matrixWorld).applyMatrix4($d5b85d29c0b78636$var$_matrix$1);
            $d5b85d29c0b78636$var$_forward.set(0, 0, -1).transformDirection(camera.matrixWorld).transformDirection($d5b85d29c0b78636$var$_matrix$1);
            for(let i = 0, l = instanceInfo.length; i < l; i++)if (instanceInfo[i].visible && instanceInfo[i].active) {
                const geometryId = instanceInfo[i].geometryIndex;
                // get the bounds in world space
                this.getMatrixAt(i, $d5b85d29c0b78636$var$_matrix$1);
                this.getBoundingSphereAt(geometryId, $d5b85d29c0b78636$var$_sphere$2).applyMatrix4($d5b85d29c0b78636$var$_matrix$1);
                // determine whether the batched geometry is within the frustum
                let culled = false;
                if (perObjectFrustumCulled) culled = !$d5b85d29c0b78636$var$_frustum.intersectsSphere($d5b85d29c0b78636$var$_sphere$2);
                if (!culled) {
                    // get the distance from camera used for sorting
                    const geometryInfo = geometryInfoList[geometryId];
                    const z = $d5b85d29c0b78636$var$_temp.subVectors($d5b85d29c0b78636$var$_sphere$2.center, $d5b85d29c0b78636$var$_vector$5).dot($d5b85d29c0b78636$var$_forward);
                    $d5b85d29c0b78636$var$_renderList.push(geometryInfo.start, geometryInfo.count, z, i);
                }
            }
            // Sort the draw ranges and prep for rendering
            const list = $d5b85d29c0b78636$var$_renderList.list;
            const customSort = this.customSort;
            if (customSort === null) list.sort(material.transparent ? $d5b85d29c0b78636$var$sortTransparent : $d5b85d29c0b78636$var$sortOpaque);
            else customSort.call(this, list, camera);
            for(let i = 0, l = list.length; i < l; i++){
                const item = list[i];
                multiDrawStarts[multiDrawCount] = item.start * bytesPerElement;
                multiDrawCounts[multiDrawCount] = item.count;
                indirectArray[multiDrawCount] = item.index;
                multiDrawCount++;
            }
            $d5b85d29c0b78636$var$_renderList.reset();
        } else {
            for(let i = 0, l = instanceInfo.length; i < l; i++)if (instanceInfo[i].visible && instanceInfo[i].active) {
                const geometryId = instanceInfo[i].geometryIndex;
                // determine whether the batched geometry is within the frustum
                let culled = false;
                if (perObjectFrustumCulled) {
                    // get the bounds in world space
                    this.getMatrixAt(i, $d5b85d29c0b78636$var$_matrix$1);
                    this.getBoundingSphereAt(geometryId, $d5b85d29c0b78636$var$_sphere$2).applyMatrix4($d5b85d29c0b78636$var$_matrix$1);
                    culled = !$d5b85d29c0b78636$var$_frustum.intersectsSphere($d5b85d29c0b78636$var$_sphere$2);
                }
                if (!culled) {
                    const geometryInfo = geometryInfoList[geometryId];
                    multiDrawStarts[multiDrawCount] = geometryInfo.start * bytesPerElement;
                    multiDrawCounts[multiDrawCount] = geometryInfo.count;
                    indirectArray[multiDrawCount] = i;
                    multiDrawCount++;
                }
            }
        }
        indirectTexture.needsUpdate = true;
        this._multiDrawCount = multiDrawCount;
        this._visibilityChanged = false;
    }
    onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial /* , group */ ) {
        this.onBeforeRender(renderer, null, shadowCamera, geometry, depthMaterial);
    }
}
class $d5b85d29c0b78636$export$fbaaa33907730a0c extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isLineBasicMaterial = true;
        this.type = 'LineBasicMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff);
        this.map = null;
        this.linewidth = 1;
        this.linecap = 'round';
        this.linejoin = 'round';
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.map = source.map;
        this.linewidth = source.linewidth;
        this.linecap = source.linecap;
        this.linejoin = source.linejoin;
        this.fog = source.fog;
        return this;
    }
}
const $d5b85d29c0b78636$var$_vStart = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_vEnd = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_inverseMatrix$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_ray$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$a186db52eed6d40e();
const $d5b85d29c0b78636$var$_sphere$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
const $d5b85d29c0b78636$var$_intersectPointOnRay = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_intersectPointOnSegment = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$17d680238e50603e extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(geometry = new $d5b85d29c0b78636$export$b7be63a67df8959(), material = new $d5b85d29c0b78636$export$fbaaa33907730a0c()){
        super();
        this.isLine = true;
        this.type = 'Line';
        this.geometry = geometry;
        this.material = material;
        this.updateMorphTargets();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
        this.geometry = source.geometry;
        return this;
    }
    computeLineDistances() {
        const geometry = this.geometry;
        // we assume non-indexed geometry
        if (geometry.index === null) {
            const positionAttribute = geometry.attributes.position;
            const lineDistances = [
                0
            ];
            for(let i = 1, l = positionAttribute.count; i < l; i++){
                $d5b85d29c0b78636$var$_vStart.fromBufferAttribute(positionAttribute, i - 1);
                $d5b85d29c0b78636$var$_vEnd.fromBufferAttribute(positionAttribute, i);
                lineDistances[i] = lineDistances[i - 1];
                lineDistances[i] += $d5b85d29c0b78636$var$_vStart.distanceTo($d5b85d29c0b78636$var$_vEnd);
            }
            geometry.setAttribute('lineDistance', new $d5b85d29c0b78636$export$cbe7a62641830ebd(lineDistances, 1));
        } else console.warn('THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.');
        return this;
    }
    raycast(raycaster, intersects) {
        const geometry = this.geometry;
        const matrixWorld = this.matrixWorld;
        const threshold = raycaster.params.Line.threshold;
        const drawRange = geometry.drawRange;
        // Checking boundingSphere distance to ray
        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
        $d5b85d29c0b78636$var$_sphere$1.copy(geometry.boundingSphere);
        $d5b85d29c0b78636$var$_sphere$1.applyMatrix4(matrixWorld);
        $d5b85d29c0b78636$var$_sphere$1.radius += threshold;
        if (raycaster.ray.intersectsSphere($d5b85d29c0b78636$var$_sphere$1) === false) return;
        //
        $d5b85d29c0b78636$var$_inverseMatrix$1.copy(matrixWorld).invert();
        $d5b85d29c0b78636$var$_ray$1.copy(raycaster.ray).applyMatrix4($d5b85d29c0b78636$var$_inverseMatrix$1);
        const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
        const localThresholdSq = localThreshold * localThreshold;
        const step = this.isLineSegments ? 2 : 1;
        const index = geometry.index;
        const attributes = geometry.attributes;
        const positionAttribute = attributes.position;
        if (index !== null) {
            const start = Math.max(0, drawRange.start);
            const end = Math.min(index.count, drawRange.start + drawRange.count);
            for(let i = start, l = end - 1; i < l; i += step){
                const a = index.getX(i);
                const b = index.getX(i + 1);
                const intersect = $d5b85d29c0b78636$var$checkIntersection(this, raycaster, $d5b85d29c0b78636$var$_ray$1, localThresholdSq, a, b);
                if (intersect) intersects.push(intersect);
            }
            if (this.isLineLoop) {
                const a = index.getX(end - 1);
                const b = index.getX(start);
                const intersect = $d5b85d29c0b78636$var$checkIntersection(this, raycaster, $d5b85d29c0b78636$var$_ray$1, localThresholdSq, a, b);
                if (intersect) intersects.push(intersect);
            }
        } else {
            const start = Math.max(0, drawRange.start);
            const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count);
            for(let i = start, l = end - 1; i < l; i += step){
                const intersect = $d5b85d29c0b78636$var$checkIntersection(this, raycaster, $d5b85d29c0b78636$var$_ray$1, localThresholdSq, i, i + 1);
                if (intersect) intersects.push(intersect);
            }
            if (this.isLineLoop) {
                const intersect = $d5b85d29c0b78636$var$checkIntersection(this, raycaster, $d5b85d29c0b78636$var$_ray$1, localThresholdSq, end - 1, start);
                if (intersect) intersects.push(intersect);
            }
        }
    }
    updateMorphTargets() {
        const geometry = this.geometry;
        const morphAttributes = geometry.morphAttributes;
        const keys = Object.keys(morphAttributes);
        if (keys.length > 0) {
            const morphAttribute = morphAttributes[keys[0]];
            if (morphAttribute !== undefined) {
                this.morphTargetInfluences = [];
                this.morphTargetDictionary = {};
                for(let m = 0, ml = morphAttribute.length; m < ml; m++){
                    const name = morphAttribute[m].name || String(m);
                    this.morphTargetInfluences.push(0);
                    this.morphTargetDictionary[name] = m;
                }
            }
        }
    }
}
function $d5b85d29c0b78636$var$checkIntersection(object, raycaster, ray, thresholdSq, a, b) {
    const positionAttribute = object.geometry.attributes.position;
    $d5b85d29c0b78636$var$_vStart.fromBufferAttribute(positionAttribute, a);
    $d5b85d29c0b78636$var$_vEnd.fromBufferAttribute(positionAttribute, b);
    const distSq = ray.distanceSqToSegment($d5b85d29c0b78636$var$_vStart, $d5b85d29c0b78636$var$_vEnd, $d5b85d29c0b78636$var$_intersectPointOnRay, $d5b85d29c0b78636$var$_intersectPointOnSegment);
    if (distSq > thresholdSq) return;
    $d5b85d29c0b78636$var$_intersectPointOnRay.applyMatrix4(object.matrixWorld); // Move back to world space for distance calculation
    const distance = raycaster.ray.origin.distanceTo($d5b85d29c0b78636$var$_intersectPointOnRay);
    if (distance < raycaster.near || distance > raycaster.far) return;
    return {
        distance: distance,
        // What do we want? intersection point on the ray or on the segment??
        // point: raycaster.ray.at( distance ),
        point: $d5b85d29c0b78636$var$_intersectPointOnSegment.clone().applyMatrix4(object.matrixWorld),
        index: a,
        face: null,
        faceIndex: null,
        barycoord: null,
        object: object
    };
}
const $d5b85d29c0b78636$var$_start = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_end = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$ff1ed10fedfdd604 extends $d5b85d29c0b78636$export$17d680238e50603e {
    constructor(geometry, material){
        super(geometry, material);
        this.isLineSegments = true;
        this.type = 'LineSegments';
    }
    computeLineDistances() {
        const geometry = this.geometry;
        // we assume non-indexed geometry
        if (geometry.index === null) {
            const positionAttribute = geometry.attributes.position;
            const lineDistances = [];
            for(let i = 0, l = positionAttribute.count; i < l; i += 2){
                $d5b85d29c0b78636$var$_start.fromBufferAttribute(positionAttribute, i);
                $d5b85d29c0b78636$var$_end.fromBufferAttribute(positionAttribute, i + 1);
                lineDistances[i] = i === 0 ? 0 : lineDistances[i - 1];
                lineDistances[i + 1] = lineDistances[i] + $d5b85d29c0b78636$var$_start.distanceTo($d5b85d29c0b78636$var$_end);
            }
            geometry.setAttribute('lineDistance', new $d5b85d29c0b78636$export$cbe7a62641830ebd(lineDistances, 1));
        } else console.warn('THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.');
        return this;
    }
}
class $d5b85d29c0b78636$export$f85a24d745e4f17d extends $d5b85d29c0b78636$export$17d680238e50603e {
    constructor(geometry, material){
        super(geometry, material);
        this.isLineLoop = true;
        this.type = 'LineLoop';
    }
}
class $d5b85d29c0b78636$export$a178c45366ce5d6b extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isPointsMaterial = true;
        this.type = 'PointsMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff);
        this.map = null;
        this.alphaMap = null;
        this.size = 1;
        this.sizeAttenuation = true;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.map = source.map;
        this.alphaMap = source.alphaMap;
        this.size = source.size;
        this.sizeAttenuation = source.sizeAttenuation;
        this.fog = source.fog;
        return this;
    }
}
const $d5b85d29c0b78636$var$_inverseMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_ray = /*@__PURE__*/ new $d5b85d29c0b78636$export$a186db52eed6d40e();
const $d5b85d29c0b78636$var$_sphere = /*@__PURE__*/ new $d5b85d29c0b78636$export$805e8b72413ccaba();
const $d5b85d29c0b78636$var$_position$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$1c787534cb11aa3e extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(geometry = new $d5b85d29c0b78636$export$b7be63a67df8959(), material = new $d5b85d29c0b78636$export$a178c45366ce5d6b()){
        super();
        this.isPoints = true;
        this.type = 'Points';
        this.geometry = geometry;
        this.material = material;
        this.updateMorphTargets();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
        this.geometry = source.geometry;
        return this;
    }
    raycast(raycaster, intersects) {
        const geometry = this.geometry;
        const matrixWorld = this.matrixWorld;
        const threshold = raycaster.params.Points.threshold;
        const drawRange = geometry.drawRange;
        // Checking boundingSphere distance to ray
        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
        $d5b85d29c0b78636$var$_sphere.copy(geometry.boundingSphere);
        $d5b85d29c0b78636$var$_sphere.applyMatrix4(matrixWorld);
        $d5b85d29c0b78636$var$_sphere.radius += threshold;
        if (raycaster.ray.intersectsSphere($d5b85d29c0b78636$var$_sphere) === false) return;
        //
        $d5b85d29c0b78636$var$_inverseMatrix.copy(matrixWorld).invert();
        $d5b85d29c0b78636$var$_ray.copy(raycaster.ray).applyMatrix4($d5b85d29c0b78636$var$_inverseMatrix);
        const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
        const localThresholdSq = localThreshold * localThreshold;
        const index = geometry.index;
        const attributes = geometry.attributes;
        const positionAttribute = attributes.position;
        if (index !== null) {
            const start = Math.max(0, drawRange.start);
            const end = Math.min(index.count, drawRange.start + drawRange.count);
            for(let i = start, il = end; i < il; i++){
                const a = index.getX(i);
                $d5b85d29c0b78636$var$_position$2.fromBufferAttribute(positionAttribute, a);
                $d5b85d29c0b78636$var$testPoint($d5b85d29c0b78636$var$_position$2, a, localThresholdSq, matrixWorld, raycaster, intersects, this);
            }
        } else {
            const start = Math.max(0, drawRange.start);
            const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count);
            for(let i = start, l = end; i < l; i++){
                $d5b85d29c0b78636$var$_position$2.fromBufferAttribute(positionAttribute, i);
                $d5b85d29c0b78636$var$testPoint($d5b85d29c0b78636$var$_position$2, i, localThresholdSq, matrixWorld, raycaster, intersects, this);
            }
        }
    }
    updateMorphTargets() {
        const geometry = this.geometry;
        const morphAttributes = geometry.morphAttributes;
        const keys = Object.keys(morphAttributes);
        if (keys.length > 0) {
            const morphAttribute = morphAttributes[keys[0]];
            if (morphAttribute !== undefined) {
                this.morphTargetInfluences = [];
                this.morphTargetDictionary = {};
                for(let m = 0, ml = morphAttribute.length; m < ml; m++){
                    const name = morphAttribute[m].name || String(m);
                    this.morphTargetInfluences.push(0);
                    this.morphTargetDictionary[name] = m;
                }
            }
        }
    }
}
function $d5b85d29c0b78636$var$testPoint(point, index, localThresholdSq, matrixWorld, raycaster, intersects, object) {
    const rayPointDistanceSq = $d5b85d29c0b78636$var$_ray.distanceSqToPoint(point);
    if (rayPointDistanceSq < localThresholdSq) {
        const intersectPoint = new $d5b85d29c0b78636$export$64b5c384219d3699();
        $d5b85d29c0b78636$var$_ray.closestPointToPoint(point, intersectPoint);
        intersectPoint.applyMatrix4(matrixWorld);
        const distance = raycaster.ray.origin.distanceTo(intersectPoint);
        if (distance < raycaster.near || distance > raycaster.far) return;
        intersects.push({
            distance: distance,
            distanceToRay: Math.sqrt(rayPointDistanceSq),
            point: intersectPoint,
            index: index,
            face: null,
            faceIndex: null,
            barycoord: null,
            object: object
        });
    }
}
class $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(){
        super();
        this.isGroup = true;
        this.type = 'Group';
    }
}
class $d5b85d29c0b78636$export$6e09d1edf8d5a25c extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy){
        super(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
        this.isVideoTexture = true;
        this.minFilter = minFilter !== undefined ? minFilter : $d5b85d29c0b78636$export$8a72f490b25c56c8;
        this.magFilter = magFilter !== undefined ? magFilter : $d5b85d29c0b78636$export$8a72f490b25c56c8;
        this.generateMipmaps = false;
        const scope = this;
        function updateVideo() {
            scope.needsUpdate = true;
            video.requestVideoFrameCallback(updateVideo);
        }
        if ('requestVideoFrameCallback' in video) video.requestVideoFrameCallback(updateVideo);
    }
    clone() {
        return new this.constructor(this.image).copy(this);
    }
    update() {
        const video = this.image;
        const hasVideoFrameCallback = 'requestVideoFrameCallback' in video;
        if (hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA) this.needsUpdate = true;
    }
}
class $d5b85d29c0b78636$export$9270d786f73ce6fe extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(width, height){
        super({
            width: width,
            height: height
        });
        this.isFramebufferTexture = true;
        this.magFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.minFilter = $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.generateMipmaps = false;
        this.needsUpdate = true;
    }
}
class $d5b85d29c0b78636$export$3466bac9141a5cc4 extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace){
        super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, colorSpace);
        this.isCompressedTexture = true;
        this.image = {
            width: width,
            height: height
        };
        this.mipmaps = mipmaps;
        // no flipping for cube textures
        // (also flipping doesn't work for compressed textures )
        this.flipY = false;
        // can't generate mipmaps for compressed textures
        // mips must be embedded in DDS files
        this.generateMipmaps = false;
    }
}
class $d5b85d29c0b78636$export$5fe6b8e34b274fcb extends $d5b85d29c0b78636$export$3466bac9141a5cc4 {
    constructor(mipmaps, width, height, depth, format, type){
        super(mipmaps, width, height, format, type);
        this.isCompressedArrayTexture = true;
        this.image.depth = depth;
        this.wrapR = $d5b85d29c0b78636$export$9d9334239a5a5e06;
        this.layerUpdates = new Set();
    }
    addLayerUpdate(layerIndex) {
        this.layerUpdates.add(layerIndex);
    }
    clearLayerUpdates() {
        this.layerUpdates.clear();
    }
}
class $d5b85d29c0b78636$export$d80173634de65bff extends $d5b85d29c0b78636$export$3466bac9141a5cc4 {
    constructor(images, format, type){
        super(undefined, images[0].width, images[0].height, format, type, $d5b85d29c0b78636$export$8759762a6477f2c4);
        this.isCompressedCubeTexture = true;
        this.isCubeTexture = true;
        this.image = images;
    }
}
class $d5b85d29c0b78636$export$f7189e49152d1c13 extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy){
        super(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
        this.isCanvasTexture = true;
        this.needsUpdate = true;
    }
}
class $d5b85d29c0b78636$export$fc830aa069cc8c2f extends $d5b85d29c0b78636$export$5431306cf43de24a {
    constructor(width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format = $d5b85d29c0b78636$export$c1b6b5136be58045){
        if (format !== $d5b85d29c0b78636$export$c1b6b5136be58045 && format !== $d5b85d29c0b78636$export$1e113ac2d0905829) throw new Error('DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat');
        if (type === undefined && format === $d5b85d29c0b78636$export$c1b6b5136be58045) type = $d5b85d29c0b78636$export$c3c7fc4518ebba96;
        if (type === undefined && format === $d5b85d29c0b78636$export$1e113ac2d0905829) type = $d5b85d29c0b78636$export$6c8ea339bfab1301;
        super(null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy);
        this.isDepthTexture = true;
        this.image = {
            width: width,
            height: height
        };
        this.magFilter = magFilter !== undefined ? magFilter : $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.minFilter = minFilter !== undefined ? minFilter : $d5b85d29c0b78636$export$727aa5ec3fe39bf0;
        this.flipY = false;
        this.generateMipmaps = false;
        this.compareFunction = null;
    }
    copy(source) {
        super.copy(source);
        this.compareFunction = source.compareFunction;
        return this;
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        if (this.compareFunction !== null) data.compareFunction = this.compareFunction;
        return data;
    }
}
/**
 * Extensible curve object.
 *
 * Some common of curve methods:
 * .getPoint( t, optionalTarget ), .getTangent( t, optionalTarget )
 * .getPointAt( u, optionalTarget ), .getTangentAt( u, optionalTarget )
 * .getPoints(), .getSpacedPoints()
 * .getLength()
 * .updateArcLengths()
 *
 * This following curves inherit from THREE.Curve:
 *
 * -- 2D curves --
 * THREE.ArcCurve
 * THREE.CubicBezierCurve
 * THREE.EllipseCurve
 * THREE.LineCurve
 * THREE.QuadraticBezierCurve
 * THREE.SplineCurve
 *
 * -- 3D curves --
 * THREE.CatmullRomCurve3
 * THREE.CubicBezierCurve3
 * THREE.LineCurve3
 * THREE.QuadraticBezierCurve3
 *
 * A series of curves can be represented as a THREE.CurvePath.
 *
 **/ class $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(){
        this.type = 'Curve';
        this.arcLengthDivisions = 200;
    }
    // Virtual base class method to overwrite and implement in subclasses
    //	- t [0 .. 1]
    getPoint() {
        console.warn('THREE.Curve: .getPoint() not implemented.');
        return null;
    }
    // Get point at relative position in curve according to arc length
    // - u [0 .. 1]
    getPointAt(u, optionalTarget) {
        const t = this.getUtoTmapping(u);
        return this.getPoint(t, optionalTarget);
    }
    // Get sequence of points using getPoint( t )
    getPoints(divisions = 5) {
        const points = [];
        for(let d = 0; d <= divisions; d++)points.push(this.getPoint(d / divisions));
        return points;
    }
    // Get sequence of points using getPointAt( u )
    getSpacedPoints(divisions = 5) {
        const points = [];
        for(let d = 0; d <= divisions; d++)points.push(this.getPointAt(d / divisions));
        return points;
    }
    // Get total curve arc length
    getLength() {
        const lengths = this.getLengths();
        return lengths[lengths.length - 1];
    }
    // Get list of cumulative segment lengths
    getLengths(divisions = this.arcLengthDivisions) {
        if (this.cacheArcLengths && this.cacheArcLengths.length === divisions + 1 && !this.needsUpdate) return this.cacheArcLengths;
        this.needsUpdate = false;
        const cache = [];
        let current, last = this.getPoint(0);
        let sum = 0;
        cache.push(0);
        for(let p = 1; p <= divisions; p++){
            current = this.getPoint(p / divisions);
            sum += current.distanceTo(last);
            cache.push(sum);
            last = current;
        }
        this.cacheArcLengths = cache;
        return cache; // { sums: cache, sum: sum }; Sum is in the last element.
    }
    updateArcLengths() {
        this.needsUpdate = true;
        this.getLengths();
    }
    // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
    getUtoTmapping(u, distance) {
        const arcLengths = this.getLengths();
        let i = 0;
        const il = arcLengths.length;
        let targetArcLength; // The targeted u distance value to get
        if (distance) targetArcLength = distance;
        else targetArcLength = u * arcLengths[il - 1];
        // binary search for the index with largest value smaller than target u distance
        let low = 0, high = il - 1, comparison;
        while(low <= high){
            i = Math.floor(low + (high - low) / 2); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
            comparison = arcLengths[i] - targetArcLength;
            if (comparison < 0) low = i + 1;
            else if (comparison > 0) high = i - 1;
            else {
                high = i;
                break;
            // DONE
            }
        }
        i = high;
        if (arcLengths[i] === targetArcLength) return i / (il - 1);
        // we could get finer grain at lengths, or use simple interpolation between two points
        const lengthBefore = arcLengths[i];
        const lengthAfter = arcLengths[i + 1];
        const segmentLength = lengthAfter - lengthBefore;
        // determine where we are between the 'before' and 'after' points
        const segmentFraction = (targetArcLength - lengthBefore) / segmentLength;
        // add that fractional amount to t
        const t = (i + segmentFraction) / (il - 1);
        return t;
    }
    // Returns a unit vector tangent at t
    // In case any sub curve does not implement its tangent derivation,
    // 2 points a small delta apart will be used to find its gradient
    // which seems to give a reasonable approximation
    getTangent(t, optionalTarget) {
        const delta = 0.0001;
        let t1 = t - delta;
        let t2 = t + delta;
        // Capping in case of danger
        if (t1 < 0) t1 = 0;
        if (t2 > 1) t2 = 1;
        const pt1 = this.getPoint(t1);
        const pt2 = this.getPoint(t2);
        const tangent = optionalTarget || (pt1.isVector2 ? new $d5b85d29c0b78636$export$c977b3e384af9ae1() : new $d5b85d29c0b78636$export$64b5c384219d3699());
        tangent.copy(pt2).sub(pt1).normalize();
        return tangent;
    }
    getTangentAt(u, optionalTarget) {
        const t = this.getUtoTmapping(u);
        return this.getTangent(t, optionalTarget);
    }
    computeFrenetFrames(segments, closed) {
        // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
        const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const tangents = [];
        const normals = [];
        const binormals = [];
        const vec = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const mat = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        // compute the tangent vectors for each segment on the curve
        for(let i = 0; i <= segments; i++){
            const u = i / segments;
            tangents[i] = this.getTangentAt(u, new $d5b85d29c0b78636$export$64b5c384219d3699());
        }
        // select an initial normal vector perpendicular to the first tangent vector,
        // and in the direction of the minimum tangent xyz component
        normals[0] = new $d5b85d29c0b78636$export$64b5c384219d3699();
        binormals[0] = new $d5b85d29c0b78636$export$64b5c384219d3699();
        let min = Number.MAX_VALUE;
        const tx = Math.abs(tangents[0].x);
        const ty = Math.abs(tangents[0].y);
        const tz = Math.abs(tangents[0].z);
        if (tx <= min) {
            min = tx;
            normal.set(1, 0, 0);
        }
        if (ty <= min) {
            min = ty;
            normal.set(0, 1, 0);
        }
        if (tz <= min) normal.set(0, 0, 1);
        vec.crossVectors(tangents[0], normal).normalize();
        normals[0].crossVectors(tangents[0], vec);
        binormals[0].crossVectors(tangents[0], normals[0]);
        // compute the slowly-varying normal and binormal vectors for each segment on the curve
        for(let i = 1; i <= segments; i++){
            normals[i] = normals[i - 1].clone();
            binormals[i] = binormals[i - 1].clone();
            vec.crossVectors(tangents[i - 1], tangents[i]);
            if (vec.length() > Number.EPSILON) {
                vec.normalize();
                const theta = Math.acos($d5b85d29c0b78636$var$clamp(tangents[i - 1].dot(tangents[i]), -1, 1)); // clamp for floating pt errors
                normals[i].applyMatrix4(mat.makeRotationAxis(vec, theta));
            }
            binormals[i].crossVectors(tangents[i], normals[i]);
        }
        // if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
        if (closed === true) {
            let theta = Math.acos($d5b85d29c0b78636$var$clamp(normals[0].dot(normals[segments]), -1, 1));
            theta /= segments;
            if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) theta = -theta;
            for(let i = 1; i <= segments; i++){
                // twist a little...
                normals[i].applyMatrix4(mat.makeRotationAxis(tangents[i], theta * i));
                binormals[i].crossVectors(tangents[i], normals[i]);
            }
        }
        return {
            tangents: tangents,
            normals: normals,
            binormals: binormals
        };
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(source) {
        this.arcLengthDivisions = source.arcLengthDivisions;
        return this;
    }
    toJSON() {
        const data = {
            metadata: {
                version: 4.6,
                type: 'Curve',
                generator: 'Curve.toJSON'
            }
        };
        data.arcLengthDivisions = this.arcLengthDivisions;
        data.type = this.type;
        return data;
    }
    fromJSON(json) {
        this.arcLengthDivisions = json.arcLengthDivisions;
        return this;
    }
}
class $d5b85d29c0b78636$export$3f87a931616cde04 extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(aX = 0, aY = 0, xRadius = 1, yRadius = 1, aStartAngle = 0, aEndAngle = Math.PI * 2, aClockwise = false, aRotation = 0){
        super();
        this.isEllipseCurve = true;
        this.type = 'EllipseCurve';
        this.aX = aX;
        this.aY = aY;
        this.xRadius = xRadius;
        this.yRadius = yRadius;
        this.aStartAngle = aStartAngle;
        this.aEndAngle = aEndAngle;
        this.aClockwise = aClockwise;
        this.aRotation = aRotation;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$c977b3e384af9ae1()) {
        const point = optionalTarget;
        const twoPi = Math.PI * 2;
        let deltaAngle = this.aEndAngle - this.aStartAngle;
        const samePoints = Math.abs(deltaAngle) < Number.EPSILON;
        // ensures that deltaAngle is 0 .. 2 PI
        while(deltaAngle < 0)deltaAngle += twoPi;
        while(deltaAngle > twoPi)deltaAngle -= twoPi;
        if (deltaAngle < Number.EPSILON) {
            if (samePoints) deltaAngle = 0;
            else deltaAngle = twoPi;
        }
        if (this.aClockwise === true && !samePoints) {
            if (deltaAngle === twoPi) deltaAngle = -twoPi;
            else deltaAngle = deltaAngle - twoPi;
        }
        const angle = this.aStartAngle + t * deltaAngle;
        let x = this.aX + this.xRadius * Math.cos(angle);
        let y = this.aY + this.yRadius * Math.sin(angle);
        if (this.aRotation !== 0) {
            const cos = Math.cos(this.aRotation);
            const sin = Math.sin(this.aRotation);
            const tx = x - this.aX;
            const ty = y - this.aY;
            // Rotate the point about the center of the ellipse.
            x = tx * cos - ty * sin + this.aX;
            y = tx * sin + ty * cos + this.aY;
        }
        return point.set(x, y);
    }
    copy(source) {
        super.copy(source);
        this.aX = source.aX;
        this.aY = source.aY;
        this.xRadius = source.xRadius;
        this.yRadius = source.yRadius;
        this.aStartAngle = source.aStartAngle;
        this.aEndAngle = source.aEndAngle;
        this.aClockwise = source.aClockwise;
        this.aRotation = source.aRotation;
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.aX = this.aX;
        data.aY = this.aY;
        data.xRadius = this.xRadius;
        data.yRadius = this.yRadius;
        data.aStartAngle = this.aStartAngle;
        data.aEndAngle = this.aEndAngle;
        data.aClockwise = this.aClockwise;
        data.aRotation = this.aRotation;
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.aX = json.aX;
        this.aY = json.aY;
        this.xRadius = json.xRadius;
        this.yRadius = json.yRadius;
        this.aStartAngle = json.aStartAngle;
        this.aEndAngle = json.aEndAngle;
        this.aClockwise = json.aClockwise;
        this.aRotation = json.aRotation;
        return this;
    }
}
class $d5b85d29c0b78636$export$b1eedc9aab6300e8 extends $d5b85d29c0b78636$export$3f87a931616cde04 {
    constructor(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise){
        super(aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise);
        this.isArcCurve = true;
        this.type = 'ArcCurve';
    }
}
/**
 * Centripetal CatmullRom Curve - which is useful for avoiding
 * cusps and self-intersections in non-uniform catmull rom curves.
 * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
 *
 * curve.type accepts centripetal(default), chordal and catmullrom
 * curve.tension is used for catmullrom which defaults to 0.5
 */ /*
Based on an optimized c++ solution in
 - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/
 - http://ideone.com/NoEbVM

This CubicPoly class could be used for reusing some variables and calculations,
but for three.js curve use, it could be possible inlined and flatten into a single function call
which can be placed in CurveUtils.
*/ function $d5b85d29c0b78636$var$CubicPoly() {
    let c0 = 0, c1 = 0, c2 = 0, c3 = 0;
    /*
	 * Compute coefficients for a cubic polynomial
	 *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
	 * such that
	 *   p(0) = x0, p(1) = x1
	 *  and
	 *   p'(0) = t0, p'(1) = t1.
	 */ function init(x0, x1, t0, t1) {
        c0 = x0;
        c1 = t0;
        c2 = -3 * x0 + 3 * x1 - 2 * t0 - t1;
        c3 = 2 * x0 - 2 * x1 + t0 + t1;
    }
    return {
        initCatmullRom: function(x0, x1, x2, x3, tension) {
            init(x1, x2, tension * (x2 - x0), tension * (x3 - x1));
        },
        initNonuniformCatmullRom: function(x0, x1, x2, x3, dt0, dt1, dt2) {
            // compute tangents when parameterized in [t1,t2]
            let t1 = (x1 - x0) / dt0 - (x2 - x0) / (dt0 + dt1) + (x2 - x1) / dt1;
            let t2 = (x2 - x1) / dt1 - (x3 - x1) / (dt1 + dt2) + (x3 - x2) / dt2;
            // rescale tangents for parametrization in [0,1]
            t1 *= dt1;
            t2 *= dt1;
            init(x1, x2, t1, t2);
        },
        calc: function(t) {
            const t2 = t * t;
            const t3 = t2 * t;
            return c0 + c1 * t + c2 * t2 + c3 * t3;
        }
    };
}
//
const $d5b85d29c0b78636$var$tmp = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$px = /*@__PURE__*/ new $d5b85d29c0b78636$var$CubicPoly();
const $d5b85d29c0b78636$var$py = /*@__PURE__*/ new $d5b85d29c0b78636$var$CubicPoly();
const $d5b85d29c0b78636$var$pz = /*@__PURE__*/ new $d5b85d29c0b78636$var$CubicPoly();
class $d5b85d29c0b78636$export$b9146b27c24b744c extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(points = [], closed = false, curveType = 'centripetal', tension = 0.5){
        super();
        this.isCatmullRomCurve3 = true;
        this.type = 'CatmullRomCurve3';
        this.points = points;
        this.closed = closed;
        this.curveType = curveType;
        this.tension = tension;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$64b5c384219d3699()) {
        const point = optionalTarget;
        const points = this.points;
        const l = points.length;
        const p = (l - (this.closed ? 0 : 1)) * t;
        let intPoint = Math.floor(p);
        let weight = p - intPoint;
        if (this.closed) intPoint += intPoint > 0 ? 0 : (Math.floor(Math.abs(intPoint) / l) + 1) * l;
        else if (weight === 0 && intPoint === l - 1) {
            intPoint = l - 2;
            weight = 1;
        }
        let p0, p3; // 4 points (p1 & p2 defined below)
        if (this.closed || intPoint > 0) p0 = points[(intPoint - 1) % l];
        else {
            // extrapolate first point
            $d5b85d29c0b78636$var$tmp.subVectors(points[0], points[1]).add(points[0]);
            p0 = $d5b85d29c0b78636$var$tmp;
        }
        const p1 = points[intPoint % l];
        const p2 = points[(intPoint + 1) % l];
        if (this.closed || intPoint + 2 < l) p3 = points[(intPoint + 2) % l];
        else {
            // extrapolate last point
            $d5b85d29c0b78636$var$tmp.subVectors(points[l - 1], points[l - 2]).add(points[l - 1]);
            p3 = $d5b85d29c0b78636$var$tmp;
        }
        if (this.curveType === 'centripetal' || this.curveType === 'chordal') {
            // init Centripetal / Chordal Catmull-Rom
            const pow = this.curveType === 'chordal' ? 0.5 : 0.25;
            let dt0 = Math.pow(p0.distanceToSquared(p1), pow);
            let dt1 = Math.pow(p1.distanceToSquared(p2), pow);
            let dt2 = Math.pow(p2.distanceToSquared(p3), pow);
            // safety check for repeated points
            if (dt1 < 1e-4) dt1 = 1.0;
            if (dt0 < 1e-4) dt0 = dt1;
            if (dt2 < 1e-4) dt2 = dt1;
            $d5b85d29c0b78636$var$px.initNonuniformCatmullRom(p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2);
            $d5b85d29c0b78636$var$py.initNonuniformCatmullRom(p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2);
            $d5b85d29c0b78636$var$pz.initNonuniformCatmullRom(p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2);
        } else if (this.curveType === 'catmullrom') {
            $d5b85d29c0b78636$var$px.initCatmullRom(p0.x, p1.x, p2.x, p3.x, this.tension);
            $d5b85d29c0b78636$var$py.initCatmullRom(p0.y, p1.y, p2.y, p3.y, this.tension);
            $d5b85d29c0b78636$var$pz.initCatmullRom(p0.z, p1.z, p2.z, p3.z, this.tension);
        }
        point.set($d5b85d29c0b78636$var$px.calc(weight), $d5b85d29c0b78636$var$py.calc(weight), $d5b85d29c0b78636$var$pz.calc(weight));
        return point;
    }
    copy(source) {
        super.copy(source);
        this.points = [];
        for(let i = 0, l = source.points.length; i < l; i++){
            const point = source.points[i];
            this.points.push(point.clone());
        }
        this.closed = source.closed;
        this.curveType = source.curveType;
        this.tension = source.tension;
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.points = [];
        for(let i = 0, l = this.points.length; i < l; i++){
            const point = this.points[i];
            data.points.push(point.toArray());
        }
        data.closed = this.closed;
        data.curveType = this.curveType;
        data.tension = this.tension;
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.points = [];
        for(let i = 0, l = json.points.length; i < l; i++){
            const point = json.points[i];
            this.points.push(new $d5b85d29c0b78636$export$64b5c384219d3699().fromArray(point));
        }
        this.closed = json.closed;
        this.curveType = json.curveType;
        this.tension = json.tension;
        return this;
    }
}
/**
 * Bezier Curves formulas obtained from
 * https://en.wikipedia.org/wiki/B%C3%A9zier_curve
 */ function $d5b85d29c0b78636$var$CatmullRom(t, p0, p1, p2, p3) {
    const v0 = (p2 - p0) * 0.5;
    const v1 = (p3 - p1) * 0.5;
    const t2 = t * t;
    const t3 = t * t2;
    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
}
//
function $d5b85d29c0b78636$var$QuadraticBezierP0(t, p) {
    const k = 1 - t;
    return k * k * p;
}
function $d5b85d29c0b78636$var$QuadraticBezierP1(t, p) {
    return 2 * (1 - t) * t * p;
}
function $d5b85d29c0b78636$var$QuadraticBezierP2(t, p) {
    return t * t * p;
}
function $d5b85d29c0b78636$var$QuadraticBezier(t, p0, p1, p2) {
    return $d5b85d29c0b78636$var$QuadraticBezierP0(t, p0) + $d5b85d29c0b78636$var$QuadraticBezierP1(t, p1) + $d5b85d29c0b78636$var$QuadraticBezierP2(t, p2);
}
//
function $d5b85d29c0b78636$var$CubicBezierP0(t, p) {
    const k = 1 - t;
    return k * k * k * p;
}
function $d5b85d29c0b78636$var$CubicBezierP1(t, p) {
    const k = 1 - t;
    return 3 * k * k * t * p;
}
function $d5b85d29c0b78636$var$CubicBezierP2(t, p) {
    return 3 * (1 - t) * t * t * p;
}
function $d5b85d29c0b78636$var$CubicBezierP3(t, p) {
    return t * t * t * p;
}
function $d5b85d29c0b78636$var$CubicBezier(t, p0, p1, p2, p3) {
    return $d5b85d29c0b78636$var$CubicBezierP0(t, p0) + $d5b85d29c0b78636$var$CubicBezierP1(t, p1) + $d5b85d29c0b78636$var$CubicBezierP2(t, p2) + $d5b85d29c0b78636$var$CubicBezierP3(t, p3);
}
class $d5b85d29c0b78636$export$e36650d36468bb39 extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(v0 = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), v1 = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), v2 = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), v3 = new $d5b85d29c0b78636$export$c977b3e384af9ae1()){
        super();
        this.isCubicBezierCurve = true;
        this.type = 'CubicBezierCurve';
        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$c977b3e384af9ae1()) {
        const point = optionalTarget;
        const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;
        point.set($d5b85d29c0b78636$var$CubicBezier(t, v0.x, v1.x, v2.x, v3.x), $d5b85d29c0b78636$var$CubicBezier(t, v0.y, v1.y, v2.y, v3.y));
        return point;
    }
    copy(source) {
        super.copy(source);
        this.v0.copy(source.v0);
        this.v1.copy(source.v1);
        this.v2.copy(source.v2);
        this.v3.copy(source.v3);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        data.v3 = this.v3.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.v0.fromArray(json.v0);
        this.v1.fromArray(json.v1);
        this.v2.fromArray(json.v2);
        this.v3.fromArray(json.v3);
        return this;
    }
}
class $d5b85d29c0b78636$export$13d5f1c9525f246c extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(v0 = new $d5b85d29c0b78636$export$64b5c384219d3699(), v1 = new $d5b85d29c0b78636$export$64b5c384219d3699(), v2 = new $d5b85d29c0b78636$export$64b5c384219d3699(), v3 = new $d5b85d29c0b78636$export$64b5c384219d3699()){
        super();
        this.isCubicBezierCurve3 = true;
        this.type = 'CubicBezierCurve3';
        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$64b5c384219d3699()) {
        const point = optionalTarget;
        const v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;
        point.set($d5b85d29c0b78636$var$CubicBezier(t, v0.x, v1.x, v2.x, v3.x), $d5b85d29c0b78636$var$CubicBezier(t, v0.y, v1.y, v2.y, v3.y), $d5b85d29c0b78636$var$CubicBezier(t, v0.z, v1.z, v2.z, v3.z));
        return point;
    }
    copy(source) {
        super.copy(source);
        this.v0.copy(source.v0);
        this.v1.copy(source.v1);
        this.v2.copy(source.v2);
        this.v3.copy(source.v3);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        data.v3 = this.v3.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.v0.fromArray(json.v0);
        this.v1.fromArray(json.v1);
        this.v2.fromArray(json.v2);
        this.v3.fromArray(json.v3);
        return this;
    }
}
class $d5b85d29c0b78636$export$ab2e07e76531a47e extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(v1 = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), v2 = new $d5b85d29c0b78636$export$c977b3e384af9ae1()){
        super();
        this.isLineCurve = true;
        this.type = 'LineCurve';
        this.v1 = v1;
        this.v2 = v2;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$c977b3e384af9ae1()) {
        const point = optionalTarget;
        if (t === 1) point.copy(this.v2);
        else {
            point.copy(this.v2).sub(this.v1);
            point.multiplyScalar(t).add(this.v1);
        }
        return point;
    }
    // Line curve is linear, so we can overwrite default getPointAt
    getPointAt(u, optionalTarget) {
        return this.getPoint(u, optionalTarget);
    }
    getTangent(t, optionalTarget = new $d5b85d29c0b78636$export$c977b3e384af9ae1()) {
        return optionalTarget.subVectors(this.v2, this.v1).normalize();
    }
    getTangentAt(u, optionalTarget) {
        return this.getTangent(u, optionalTarget);
    }
    copy(source) {
        super.copy(source);
        this.v1.copy(source.v1);
        this.v2.copy(source.v2);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.v1.fromArray(json.v1);
        this.v2.fromArray(json.v2);
        return this;
    }
}
class $d5b85d29c0b78636$export$1fdfd9d9cf487600 extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(v1 = new $d5b85d29c0b78636$export$64b5c384219d3699(), v2 = new $d5b85d29c0b78636$export$64b5c384219d3699()){
        super();
        this.isLineCurve3 = true;
        this.type = 'LineCurve3';
        this.v1 = v1;
        this.v2 = v2;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$64b5c384219d3699()) {
        const point = optionalTarget;
        if (t === 1) point.copy(this.v2);
        else {
            point.copy(this.v2).sub(this.v1);
            point.multiplyScalar(t).add(this.v1);
        }
        return point;
    }
    // Line curve is linear, so we can overwrite default getPointAt
    getPointAt(u, optionalTarget) {
        return this.getPoint(u, optionalTarget);
    }
    getTangent(t, optionalTarget = new $d5b85d29c0b78636$export$64b5c384219d3699()) {
        return optionalTarget.subVectors(this.v2, this.v1).normalize();
    }
    getTangentAt(u, optionalTarget) {
        return this.getTangent(u, optionalTarget);
    }
    copy(source) {
        super.copy(source);
        this.v1.copy(source.v1);
        this.v2.copy(source.v2);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.v1.fromArray(json.v1);
        this.v2.fromArray(json.v2);
        return this;
    }
}
class $d5b85d29c0b78636$export$5938c4ee491a43ad extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(v0 = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), v1 = new $d5b85d29c0b78636$export$c977b3e384af9ae1(), v2 = new $d5b85d29c0b78636$export$c977b3e384af9ae1()){
        super();
        this.isQuadraticBezierCurve = true;
        this.type = 'QuadraticBezierCurve';
        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$c977b3e384af9ae1()) {
        const point = optionalTarget;
        const v0 = this.v0, v1 = this.v1, v2 = this.v2;
        point.set($d5b85d29c0b78636$var$QuadraticBezier(t, v0.x, v1.x, v2.x), $d5b85d29c0b78636$var$QuadraticBezier(t, v0.y, v1.y, v2.y));
        return point;
    }
    copy(source) {
        super.copy(source);
        this.v0.copy(source.v0);
        this.v1.copy(source.v1);
        this.v2.copy(source.v2);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.v0.fromArray(json.v0);
        this.v1.fromArray(json.v1);
        this.v2.fromArray(json.v2);
        return this;
    }
}
class $d5b85d29c0b78636$export$bf3f4c7e459f90fc extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(v0 = new $d5b85d29c0b78636$export$64b5c384219d3699(), v1 = new $d5b85d29c0b78636$export$64b5c384219d3699(), v2 = new $d5b85d29c0b78636$export$64b5c384219d3699()){
        super();
        this.isQuadraticBezierCurve3 = true;
        this.type = 'QuadraticBezierCurve3';
        this.v0 = v0;
        this.v1 = v1;
        this.v2 = v2;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$64b5c384219d3699()) {
        const point = optionalTarget;
        const v0 = this.v0, v1 = this.v1, v2 = this.v2;
        point.set($d5b85d29c0b78636$var$QuadraticBezier(t, v0.x, v1.x, v2.x), $d5b85d29c0b78636$var$QuadraticBezier(t, v0.y, v1.y, v2.y), $d5b85d29c0b78636$var$QuadraticBezier(t, v0.z, v1.z, v2.z));
        return point;
    }
    copy(source) {
        super.copy(source);
        this.v0.copy(source.v0);
        this.v1.copy(source.v1);
        this.v2.copy(source.v2);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.v0 = this.v0.toArray();
        data.v1 = this.v1.toArray();
        data.v2 = this.v2.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.v0.fromArray(json.v0);
        this.v1.fromArray(json.v1);
        this.v2.fromArray(json.v2);
        return this;
    }
}
class $d5b85d29c0b78636$export$d3bdd77da77afc1b extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(points = []){
        super();
        this.isSplineCurve = true;
        this.type = 'SplineCurve';
        this.points = points;
    }
    getPoint(t, optionalTarget = new $d5b85d29c0b78636$export$c977b3e384af9ae1()) {
        const point = optionalTarget;
        const points = this.points;
        const p = (points.length - 1) * t;
        const intPoint = Math.floor(p);
        const weight = p - intPoint;
        const p0 = points[intPoint === 0 ? intPoint : intPoint - 1];
        const p1 = points[intPoint];
        const p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1];
        const p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2];
        point.set($d5b85d29c0b78636$var$CatmullRom(weight, p0.x, p1.x, p2.x, p3.x), $d5b85d29c0b78636$var$CatmullRom(weight, p0.y, p1.y, p2.y, p3.y));
        return point;
    }
    copy(source) {
        super.copy(source);
        this.points = [];
        for(let i = 0, l = source.points.length; i < l; i++){
            const point = source.points[i];
            this.points.push(point.clone());
        }
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.points = [];
        for(let i = 0, l = this.points.length; i < l; i++){
            const point = this.points[i];
            data.points.push(point.toArray());
        }
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.points = [];
        for(let i = 0, l = json.points.length; i < l; i++){
            const point = json.points[i];
            this.points.push(new $d5b85d29c0b78636$export$c977b3e384af9ae1().fromArray(point));
        }
        return this;
    }
}
var $d5b85d29c0b78636$var$Curves = /*#__PURE__*/ Object.freeze({
    __proto__: null,
    ArcCurve: $d5b85d29c0b78636$export$b1eedc9aab6300e8,
    CatmullRomCurve3: $d5b85d29c0b78636$export$b9146b27c24b744c,
    CubicBezierCurve: $d5b85d29c0b78636$export$e36650d36468bb39,
    CubicBezierCurve3: $d5b85d29c0b78636$export$13d5f1c9525f246c,
    EllipseCurve: $d5b85d29c0b78636$export$3f87a931616cde04,
    LineCurve: $d5b85d29c0b78636$export$ab2e07e76531a47e,
    LineCurve3: $d5b85d29c0b78636$export$1fdfd9d9cf487600,
    QuadraticBezierCurve: $d5b85d29c0b78636$export$5938c4ee491a43ad,
    QuadraticBezierCurve3: $d5b85d29c0b78636$export$bf3f4c7e459f90fc,
    SplineCurve: $d5b85d29c0b78636$export$d3bdd77da77afc1b
});
/**************************************************************
 *	Curved Path - a curve path is simply a array of connected
 *  curves, but retains the api of a curve
 **************************************************************/ class $d5b85d29c0b78636$export$4aaf9b66af1bbf2c extends $d5b85d29c0b78636$export$b0e83c3ef8d2db1 {
    constructor(){
        super();
        this.type = 'CurvePath';
        this.curves = [];
        this.autoClose = false; // Automatically closes the path
    }
    add(curve) {
        this.curves.push(curve);
    }
    closePath() {
        // Add a line curve if start and end of lines are not connected
        const startPoint = this.curves[0].getPoint(0);
        const endPoint = this.curves[this.curves.length - 1].getPoint(1);
        if (!startPoint.equals(endPoint)) {
            const lineType = startPoint.isVector2 === true ? 'LineCurve' : 'LineCurve3';
            this.curves.push(new $d5b85d29c0b78636$var$Curves[lineType](endPoint, startPoint));
        }
        return this;
    }
    // To get accurate point with reference to
    // entire path distance at time t,
    // following has to be done:
    // 1. Length of each sub path have to be known
    // 2. Locate and identify type of curve
    // 3. Get t for the curve
    // 4. Return curve.getPointAt(t')
    getPoint(t, optionalTarget) {
        const d = t * this.getLength();
        const curveLengths = this.getCurveLengths();
        let i = 0;
        // To think about boundaries points.
        while(i < curveLengths.length){
            if (curveLengths[i] >= d) {
                const diff = curveLengths[i] - d;
                const curve = this.curves[i];
                const segmentLength = curve.getLength();
                const u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;
                return curve.getPointAt(u, optionalTarget);
            }
            i++;
        }
        return null;
    // loop where sum != 0, sum > d , sum+1 <d
    }
    // We cannot use the default THREE.Curve getPoint() with getLength() because in
    // THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
    // getPoint() depends on getLength
    getLength() {
        const lens = this.getCurveLengths();
        return lens[lens.length - 1];
    }
    // cacheLengths must be recalculated.
    updateArcLengths() {
        this.needsUpdate = true;
        this.cacheLengths = null;
        this.getCurveLengths();
    }
    // Compute lengths and cache them
    // We cannot overwrite getLengths() because UtoT mapping uses it.
    getCurveLengths() {
        // We use cache values if curves and cache array are same length
        if (this.cacheLengths && this.cacheLengths.length === this.curves.length) return this.cacheLengths;
        // Get length of sub-curve
        // Push sums into cached array
        const lengths = [];
        let sums = 0;
        for(let i = 0, l = this.curves.length; i < l; i++){
            sums += this.curves[i].getLength();
            lengths.push(sums);
        }
        this.cacheLengths = lengths;
        return lengths;
    }
    getSpacedPoints(divisions = 40) {
        const points = [];
        for(let i = 0; i <= divisions; i++)points.push(this.getPoint(i / divisions));
        if (this.autoClose) points.push(points[0]);
        return points;
    }
    getPoints(divisions = 12) {
        const points = [];
        let last;
        for(let i = 0, curves = this.curves; i < curves.length; i++){
            const curve = curves[i];
            const resolution = curve.isEllipseCurve ? divisions * 2 : curve.isLineCurve || curve.isLineCurve3 ? 1 : curve.isSplineCurve ? divisions * curve.points.length : divisions;
            const pts = curve.getPoints(resolution);
            for(let j = 0; j < pts.length; j++){
                const point = pts[j];
                if (last && last.equals(point)) continue; // ensures no consecutive points are duplicates
                points.push(point);
                last = point;
            }
        }
        if (this.autoClose && points.length > 1 && !points[points.length - 1].equals(points[0])) points.push(points[0]);
        return points;
    }
    copy(source) {
        super.copy(source);
        this.curves = [];
        for(let i = 0, l = source.curves.length; i < l; i++){
            const curve = source.curves[i];
            this.curves.push(curve.clone());
        }
        this.autoClose = source.autoClose;
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.autoClose = this.autoClose;
        data.curves = [];
        for(let i = 0, l = this.curves.length; i < l; i++){
            const curve = this.curves[i];
            data.curves.push(curve.toJSON());
        }
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.autoClose = json.autoClose;
        this.curves = [];
        for(let i = 0, l = json.curves.length; i < l; i++){
            const curve = json.curves[i];
            this.curves.push(new $d5b85d29c0b78636$var$Curves[curve.type]().fromJSON(curve));
        }
        return this;
    }
}
class $d5b85d29c0b78636$export$4b2950bdac9b6ee9 extends $d5b85d29c0b78636$export$4aaf9b66af1bbf2c {
    constructor(points){
        super();
        this.type = 'Path';
        this.currentPoint = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
        if (points) this.setFromPoints(points);
    }
    setFromPoints(points) {
        this.moveTo(points[0].x, points[0].y);
        for(let i = 1, l = points.length; i < l; i++)this.lineTo(points[i].x, points[i].y);
        return this;
    }
    moveTo(x, y) {
        this.currentPoint.set(x, y); // TODO consider referencing vectors instead of copying?
        return this;
    }
    lineTo(x, y) {
        const curve = new $d5b85d29c0b78636$export$ab2e07e76531a47e(this.currentPoint.clone(), new $d5b85d29c0b78636$export$c977b3e384af9ae1(x, y));
        this.curves.push(curve);
        this.currentPoint.set(x, y);
        return this;
    }
    quadraticCurveTo(aCPx, aCPy, aX, aY) {
        const curve = new $d5b85d29c0b78636$export$5938c4ee491a43ad(this.currentPoint.clone(), new $d5b85d29c0b78636$export$c977b3e384af9ae1(aCPx, aCPy), new $d5b85d29c0b78636$export$c977b3e384af9ae1(aX, aY));
        this.curves.push(curve);
        this.currentPoint.set(aX, aY);
        return this;
    }
    bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
        const curve = new $d5b85d29c0b78636$export$e36650d36468bb39(this.currentPoint.clone(), new $d5b85d29c0b78636$export$c977b3e384af9ae1(aCP1x, aCP1y), new $d5b85d29c0b78636$export$c977b3e384af9ae1(aCP2x, aCP2y), new $d5b85d29c0b78636$export$c977b3e384af9ae1(aX, aY));
        this.curves.push(curve);
        this.currentPoint.set(aX, aY);
        return this;
    }
    splineThru(pts /*Array of Vector*/ ) {
        const npts = [
            this.currentPoint.clone()
        ].concat(pts);
        const curve = new $d5b85d29c0b78636$export$d3bdd77da77afc1b(npts);
        this.curves.push(curve);
        this.currentPoint.copy(pts[pts.length - 1]);
        return this;
    }
    arc(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
        const x0 = this.currentPoint.x;
        const y0 = this.currentPoint.y;
        this.absarc(aX + x0, aY + y0, aRadius, aStartAngle, aEndAngle, aClockwise);
        return this;
    }
    absarc(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
        this.absellipse(aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise);
        return this;
    }
    ellipse(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
        const x0 = this.currentPoint.x;
        const y0 = this.currentPoint.y;
        this.absellipse(aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation);
        return this;
    }
    absellipse(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
        const curve = new $d5b85d29c0b78636$export$3f87a931616cde04(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation);
        if (this.curves.length > 0) {
            // if a previous curve is present, attempt to join
            const firstPoint = curve.getPoint(0);
            if (!firstPoint.equals(this.currentPoint)) this.lineTo(firstPoint.x, firstPoint.y);
        }
        this.curves.push(curve);
        const lastPoint = curve.getPoint(1);
        this.currentPoint.copy(lastPoint);
        return this;
    }
    copy(source) {
        super.copy(source);
        this.currentPoint.copy(source.currentPoint);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.currentPoint = this.currentPoint.toArray();
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.currentPoint.fromArray(json.currentPoint);
        return this;
    }
}
class $d5b85d29c0b78636$export$6d839803fcd1882c extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(points = [
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0, -0.5),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0.5, 0),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0, 0.5)
    ], segments = 12, phiStart = 0, phiLength = Math.PI * 2){
        super();
        this.type = 'LatheGeometry';
        this.parameters = {
            points: points,
            segments: segments,
            phiStart: phiStart,
            phiLength: phiLength
        };
        segments = Math.floor(segments);
        // clamp phiLength so it's in range of [ 0, 2PI ]
        phiLength = $d5b85d29c0b78636$var$clamp(phiLength, 0, Math.PI * 2);
        // buffers
        const indices = [];
        const vertices = [];
        const uvs = [];
        const initNormals = [];
        const normals = [];
        // helper variables
        const inverseSegments = 1.0 / segments;
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const uv = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
        const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const curNormal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const prevNormal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        let dx = 0;
        let dy = 0;
        // pre-compute normals for initial "meridian"
        for(let j = 0; j <= points.length - 1; j++)switch(j){
            case 0:
                dx = points[j + 1].x - points[j].x;
                dy = points[j + 1].y - points[j].y;
                normal.x = dy * 1.0;
                normal.y = -dx;
                normal.z = dy * 0.0;
                prevNormal.copy(normal);
                normal.normalize();
                initNormals.push(normal.x, normal.y, normal.z);
                break;
            case points.length - 1:
                initNormals.push(prevNormal.x, prevNormal.y, prevNormal.z);
                break;
            default:
                dx = points[j + 1].x - points[j].x;
                dy = points[j + 1].y - points[j].y;
                normal.x = dy * 1.0;
                normal.y = -dx;
                normal.z = dy * 0.0;
                curNormal.copy(normal);
                normal.x += prevNormal.x;
                normal.y += prevNormal.y;
                normal.z += prevNormal.z;
                normal.normalize();
                initNormals.push(normal.x, normal.y, normal.z);
                prevNormal.copy(curNormal);
        }
        // generate vertices, uvs and normals
        for(let i = 0; i <= segments; i++){
            const phi = phiStart + i * inverseSegments * phiLength;
            const sin = Math.sin(phi);
            const cos = Math.cos(phi);
            for(let j = 0; j <= points.length - 1; j++){
                // vertex
                vertex.x = points[j].x * sin;
                vertex.y = points[j].y;
                vertex.z = points[j].x * cos;
                vertices.push(vertex.x, vertex.y, vertex.z);
                // uv
                uv.x = i / segments;
                uv.y = j / (points.length - 1);
                uvs.push(uv.x, uv.y);
                // normal
                const x = initNormals[3 * j + 0] * sin;
                const y = initNormals[3 * j + 1];
                const z = initNormals[3 * j + 0] * cos;
                normals.push(x, y, z);
            }
        }
        // indices
        for(let i = 0; i < segments; i++)for(let j = 0; j < points.length - 1; j++){
            const base = j + i * points.length;
            const a = base;
            const b = base + points.length;
            const c = base + points.length + 1;
            const d = base + 1;
            // faces
            indices.push(a, b, d);
            indices.push(c, d, b);
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$6d839803fcd1882c(data.points, data.segments, data.phiStart, data.phiLength);
    }
}
class $d5b85d29c0b78636$export$41680e8551036033 extends $d5b85d29c0b78636$export$6d839803fcd1882c {
    constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8){
        const path = new $d5b85d29c0b78636$export$4b2950bdac9b6ee9();
        path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0);
        path.absarc(0, length / 2, radius, 0, Math.PI * 0.5);
        super(path.getPoints(capSegments), radialSegments);
        this.type = 'CapsuleGeometry';
        this.parameters = {
            radius: radius,
            length: length,
            capSegments: capSegments,
            radialSegments: radialSegments
        };
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$41680e8551036033(data.radius, data.length, data.capSegments, data.radialSegments);
    }
}
class $d5b85d29c0b78636$export$d5c0e8d607467193 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(radius = 1, segments = 32, thetaStart = 0, thetaLength = Math.PI * 2){
        super();
        this.type = 'CircleGeometry';
        this.parameters = {
            radius: radius,
            segments: segments,
            thetaStart: thetaStart,
            thetaLength: thetaLength
        };
        segments = Math.max(3, segments);
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // helper variables
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const uv = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
        // center point
        vertices.push(0, 0, 0);
        normals.push(0, 0, 1);
        uvs.push(0.5, 0.5);
        for(let s = 0, i = 3; s <= segments; s++, i += 3){
            const segment = thetaStart + s / segments * thetaLength;
            // vertex
            vertex.x = radius * Math.cos(segment);
            vertex.y = radius * Math.sin(segment);
            vertices.push(vertex.x, vertex.y, vertex.z);
            // normal
            normals.push(0, 0, 1);
            // uvs
            uv.x = (vertices[i] / radius + 1) / 2;
            uv.y = (vertices[i + 1] / radius + 1) / 2;
            uvs.push(uv.x, uv.y);
        }
        // indices
        for(let i = 1; i <= segments; i++)indices.push(i, i + 1, 0);
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$d5c0e8d607467193(data.radius, data.segments, data.thetaStart, data.thetaLength);
    }
}
class $d5b85d29c0b78636$export$68f745719dbe5198 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(radiusTop = 1, radiusBottom = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2){
        super();
        this.type = 'CylinderGeometry';
        this.parameters = {
            radiusTop: radiusTop,
            radiusBottom: radiusBottom,
            height: height,
            radialSegments: radialSegments,
            heightSegments: heightSegments,
            openEnded: openEnded,
            thetaStart: thetaStart,
            thetaLength: thetaLength
        };
        const scope = this;
        radialSegments = Math.floor(radialSegments);
        heightSegments = Math.floor(heightSegments);
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // helper variables
        let index = 0;
        const indexArray = [];
        const halfHeight = height / 2;
        let groupStart = 0;
        // generate geometry
        generateTorso();
        if (openEnded === false) {
            if (radiusTop > 0) generateCap(true);
            if (radiusBottom > 0) generateCap(false);
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
        function generateTorso() {
            const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
            let groupCount = 0;
            // this will be used to calculate the normal
            const slope = (radiusBottom - radiusTop) / height;
            // generate vertices, normals and uvs
            for(let y = 0; y <= heightSegments; y++){
                const indexRow = [];
                const v = y / heightSegments;
                // calculate the radius of the current row
                const radius = v * (radiusBottom - radiusTop) + radiusTop;
                for(let x = 0; x <= radialSegments; x++){
                    const u = x / radialSegments;
                    const theta = u * thetaLength + thetaStart;
                    const sinTheta = Math.sin(theta);
                    const cosTheta = Math.cos(theta);
                    // vertex
                    vertex.x = radius * sinTheta;
                    vertex.y = -v * height + halfHeight;
                    vertex.z = radius * cosTheta;
                    vertices.push(vertex.x, vertex.y, vertex.z);
                    // normal
                    normal.set(sinTheta, slope, cosTheta).normalize();
                    normals.push(normal.x, normal.y, normal.z);
                    // uv
                    uvs.push(u, 1 - v);
                    // save index of vertex in respective row
                    indexRow.push(index++);
                }
                // now save vertices of the row in our index array
                indexArray.push(indexRow);
            }
            // generate indices
            for(let x = 0; x < radialSegments; x++)for(let y = 0; y < heightSegments; y++){
                // we use the index array to access the correct indices
                const a = indexArray[y][x];
                const b = indexArray[y + 1][x];
                const c = indexArray[y + 1][x + 1];
                const d = indexArray[y][x + 1];
                // faces
                if (radiusTop > 0 || y !== 0) {
                    indices.push(a, b, d);
                    groupCount += 3;
                }
                if (radiusBottom > 0 || y !== heightSegments - 1) {
                    indices.push(b, c, d);
                    groupCount += 3;
                }
            }
            // add a group to the geometry. this will ensure multi material support
            scope.addGroup(groupStart, groupCount, 0);
            // calculate new start value for groups
            groupStart += groupCount;
        }
        function generateCap(top) {
            // save the index of the first center vertex
            const centerIndexStart = index;
            const uv = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
            const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
            let groupCount = 0;
            const radius = top === true ? radiusTop : radiusBottom;
            const sign = top === true ? 1 : -1;
            // first we generate the center vertex data of the cap.
            // because the geometry needs one set of uvs per face,
            // we must generate a center vertex per face/segment
            for(let x = 1; x <= radialSegments; x++){
                // vertex
                vertices.push(0, halfHeight * sign, 0);
                // normal
                normals.push(0, sign, 0);
                // uv
                uvs.push(0.5, 0.5);
                // increase index
                index++;
            }
            // save the index of the last center vertex
            const centerIndexEnd = index;
            // now we generate the surrounding vertices, normals and uvs
            for(let x = 0; x <= radialSegments; x++){
                const u = x / radialSegments;
                const theta = u * thetaLength + thetaStart;
                const cosTheta = Math.cos(theta);
                const sinTheta = Math.sin(theta);
                // vertex
                vertex.x = radius * sinTheta;
                vertex.y = halfHeight * sign;
                vertex.z = radius * cosTheta;
                vertices.push(vertex.x, vertex.y, vertex.z);
                // normal
                normals.push(0, sign, 0);
                // uv
                uv.x = cosTheta * 0.5 + 0.5;
                uv.y = sinTheta * 0.5 * sign + 0.5;
                uvs.push(uv.x, uv.y);
                // increase index
                index++;
            }
            // generate indices
            for(let x = 0; x < radialSegments; x++){
                const c = centerIndexStart + x;
                const i = centerIndexEnd + x;
                if (top === true) // face top
                indices.push(i, i + 1, c);
                else // face bottom
                indices.push(i + 1, i, c);
                groupCount += 3;
            }
            // add a group to the geometry. this will ensure multi material support
            scope.addGroup(groupStart, groupCount, top === true ? 1 : 2);
            // calculate new start value for groups
            groupStart += groupCount;
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$68f745719dbe5198(data.radiusTop, data.radiusBottom, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength);
    }
}
class $d5b85d29c0b78636$export$a7a48974f285c9b3 extends $d5b85d29c0b78636$export$68f745719dbe5198 {
    constructor(radius = 1, height = 1, radialSegments = 32, heightSegments = 1, openEnded = false, thetaStart = 0, thetaLength = Math.PI * 2){
        super(0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength);
        this.type = 'ConeGeometry';
        this.parameters = {
            radius: radius,
            height: height,
            radialSegments: radialSegments,
            heightSegments: heightSegments,
            openEnded: openEnded,
            thetaStart: thetaStart,
            thetaLength: thetaLength
        };
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$a7a48974f285c9b3(data.radius, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength);
    }
}
class $d5b85d29c0b78636$export$60e57a7d3f20ff65 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(vertices = [], indices = [], radius = 1, detail = 0){
        super();
        this.type = 'PolyhedronGeometry';
        this.parameters = {
            vertices: vertices,
            indices: indices,
            radius: radius,
            detail: detail
        };
        // default buffer data
        const vertexBuffer = [];
        const uvBuffer = [];
        // the subdivision creates the vertex buffer data
        subdivide(detail);
        // all vertices should lie on a conceptual sphere with a given radius
        applyRadius(radius);
        // finally, create the uv data
        generateUVs();
        // build non-indexed geometry
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertexBuffer, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertexBuffer.slice(), 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvBuffer, 2));
        if (detail === 0) this.computeVertexNormals(); // flat normals
        else this.normalizeNormals(); // smooth normals
        // helper functions
        function subdivide(detail) {
            const a = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const b = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const c = new $d5b85d29c0b78636$export$64b5c384219d3699();
            // iterate over all faces and apply a subdivision with the given detail value
            for(let i = 0; i < indices.length; i += 3){
                // get the vertices of the face
                getVertexByIndex(indices[i + 0], a);
                getVertexByIndex(indices[i + 1], b);
                getVertexByIndex(indices[i + 2], c);
                // perform subdivision
                subdivideFace(a, b, c, detail);
            }
        }
        function subdivideFace(a, b, c, detail) {
            const cols = detail + 1;
            // we use this multidimensional array as a data structure for creating the subdivision
            const v = [];
            // construct all of the vertices for this subdivision
            for(let i = 0; i <= cols; i++){
                v[i] = [];
                const aj = a.clone().lerp(c, i / cols);
                const bj = b.clone().lerp(c, i / cols);
                const rows = cols - i;
                for(let j = 0; j <= rows; j++)if (j === 0 && i === cols) v[i][j] = aj;
                else v[i][j] = aj.clone().lerp(bj, j / rows);
            }
            // construct all of the faces
            for(let i = 0; i < cols; i++)for(let j = 0; j < 2 * (cols - i) - 1; j++){
                const k = Math.floor(j / 2);
                if (j % 2 === 0) {
                    pushVertex(v[i][k + 1]);
                    pushVertex(v[i + 1][k]);
                    pushVertex(v[i][k]);
                } else {
                    pushVertex(v[i][k + 1]);
                    pushVertex(v[i + 1][k + 1]);
                    pushVertex(v[i + 1][k]);
                }
            }
        }
        function applyRadius(radius) {
            const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
            // iterate over the entire buffer and apply the radius to each vertex
            for(let i = 0; i < vertexBuffer.length; i += 3){
                vertex.x = vertexBuffer[i + 0];
                vertex.y = vertexBuffer[i + 1];
                vertex.z = vertexBuffer[i + 2];
                vertex.normalize().multiplyScalar(radius);
                vertexBuffer[i + 0] = vertex.x;
                vertexBuffer[i + 1] = vertex.y;
                vertexBuffer[i + 2] = vertex.z;
            }
        }
        function generateUVs() {
            const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
            for(let i = 0; i < vertexBuffer.length; i += 3){
                vertex.x = vertexBuffer[i + 0];
                vertex.y = vertexBuffer[i + 1];
                vertex.z = vertexBuffer[i + 2];
                const u = azimuth(vertex) / 2 / Math.PI + 0.5;
                const v = inclination(vertex) / Math.PI + 0.5;
                uvBuffer.push(u, 1 - v);
            }
            correctUVs();
            correctSeam();
        }
        function correctSeam() {
            // handle case when face straddles the seam, see #3269
            for(let i = 0; i < uvBuffer.length; i += 6){
                // uv data of a single face
                const x0 = uvBuffer[i + 0];
                const x1 = uvBuffer[i + 2];
                const x2 = uvBuffer[i + 4];
                const max = Math.max(x0, x1, x2);
                const min = Math.min(x0, x1, x2);
                // 0.9 is somewhat arbitrary
                if (max > 0.9 && min < 0.1) {
                    if (x0 < 0.2) uvBuffer[i + 0] += 1;
                    if (x1 < 0.2) uvBuffer[i + 2] += 1;
                    if (x2 < 0.2) uvBuffer[i + 4] += 1;
                }
            }
        }
        function pushVertex(vertex) {
            vertexBuffer.push(vertex.x, vertex.y, vertex.z);
        }
        function getVertexByIndex(index, vertex) {
            const stride = index * 3;
            vertex.x = vertices[stride + 0];
            vertex.y = vertices[stride + 1];
            vertex.z = vertices[stride + 2];
        }
        function correctUVs() {
            const a = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const b = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const c = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const centroid = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const uvA = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
            const uvB = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
            const uvC = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
            for(let i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6){
                a.set(vertexBuffer[i + 0], vertexBuffer[i + 1], vertexBuffer[i + 2]);
                b.set(vertexBuffer[i + 3], vertexBuffer[i + 4], vertexBuffer[i + 5]);
                c.set(vertexBuffer[i + 6], vertexBuffer[i + 7], vertexBuffer[i + 8]);
                uvA.set(uvBuffer[j + 0], uvBuffer[j + 1]);
                uvB.set(uvBuffer[j + 2], uvBuffer[j + 3]);
                uvC.set(uvBuffer[j + 4], uvBuffer[j + 5]);
                centroid.copy(a).add(b).add(c).divideScalar(3);
                const azi = azimuth(centroid);
                correctUV(uvA, j + 0, a, azi);
                correctUV(uvB, j + 2, b, azi);
                correctUV(uvC, j + 4, c, azi);
            }
        }
        function correctUV(uv, stride, vector, azimuth) {
            if (azimuth < 0 && uv.x === 1) uvBuffer[stride] = uv.x - 1;
            if (vector.x === 0 && vector.z === 0) uvBuffer[stride] = azimuth / 2 / Math.PI + 0.5;
        }
        // Angle around the Y axis, counter-clockwise when looking from above.
        function azimuth(vector) {
            return Math.atan2(vector.z, -vector.x);
        }
        // Angle above the XZ plane.
        function inclination(vector) {
            return Math.atan2(-vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z));
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$60e57a7d3f20ff65(data.vertices, data.indices, data.radius, data.details);
    }
}
class $d5b85d29c0b78636$export$c0babfeb8708fc9c extends $d5b85d29c0b78636$export$60e57a7d3f20ff65 {
    constructor(radius = 1, detail = 0){
        const t = (1 + Math.sqrt(5)) / 2;
        const r = 1 / t;
        const vertices = [
            // (±1, ±1, ±1)
            -1,
            -1,
            -1,
            -1,
            -1,
            1,
            -1,
            1,
            -1,
            -1,
            1,
            1,
            1,
            -1,
            -1,
            1,
            -1,
            1,
            1,
            1,
            -1,
            1,
            1,
            1,
            // (0, ±1/φ, ±φ)
            0,
            -r,
            -t,
            0,
            -r,
            t,
            0,
            r,
            -t,
            0,
            r,
            t,
            // (±1/φ, ±φ, 0)
            -r,
            -t,
            0,
            -r,
            t,
            0,
            r,
            -t,
            0,
            r,
            t,
            0,
            // (±φ, 0, ±1/φ)
            -t,
            0,
            -r,
            t,
            0,
            -r,
            -t,
            0,
            r,
            t,
            0,
            r
        ];
        const indices = [
            3,
            11,
            7,
            3,
            7,
            15,
            3,
            15,
            13,
            7,
            19,
            17,
            7,
            17,
            6,
            7,
            6,
            15,
            17,
            4,
            8,
            17,
            8,
            10,
            17,
            10,
            6,
            8,
            0,
            16,
            8,
            16,
            2,
            8,
            2,
            10,
            0,
            12,
            1,
            0,
            1,
            18,
            0,
            18,
            16,
            6,
            10,
            2,
            6,
            2,
            13,
            6,
            13,
            15,
            2,
            16,
            18,
            2,
            18,
            3,
            2,
            3,
            13,
            18,
            1,
            9,
            18,
            9,
            11,
            18,
            11,
            3,
            4,
            14,
            12,
            4,
            12,
            0,
            4,
            0,
            8,
            11,
            9,
            5,
            11,
            5,
            19,
            11,
            19,
            7,
            19,
            5,
            14,
            19,
            14,
            4,
            19,
            4,
            17,
            1,
            12,
            14,
            1,
            14,
            5,
            1,
            5,
            9
        ];
        super(vertices, indices, radius, detail);
        this.type = 'DodecahedronGeometry';
        this.parameters = {
            radius: radius,
            detail: detail
        };
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$c0babfeb8708fc9c(data.radius, data.detail);
    }
}
const $d5b85d29c0b78636$var$_v0 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v1$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_normal = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_triangle = /*@__PURE__*/ new $d5b85d29c0b78636$export$5a465592bfe74b48();
class $d5b85d29c0b78636$export$4730b1542707547f extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(geometry = null, thresholdAngle = 1){
        super();
        this.type = 'EdgesGeometry';
        this.parameters = {
            geometry: geometry,
            thresholdAngle: thresholdAngle
        };
        if (geometry !== null) {
            const precisionPoints = 4;
            const precision = Math.pow(10, precisionPoints);
            const thresholdDot = Math.cos($d5b85d29c0b78636$var$DEG2RAD * thresholdAngle);
            const indexAttr = geometry.getIndex();
            const positionAttr = geometry.getAttribute('position');
            const indexCount = indexAttr ? indexAttr.count : positionAttr.count;
            const indexArr = [
                0,
                0,
                0
            ];
            const vertKeys = [
                'a',
                'b',
                'c'
            ];
            const hashes = new Array(3);
            const edgeData = {};
            const vertices = [];
            for(let i = 0; i < indexCount; i += 3){
                if (indexAttr) {
                    indexArr[0] = indexAttr.getX(i);
                    indexArr[1] = indexAttr.getX(i + 1);
                    indexArr[2] = indexAttr.getX(i + 2);
                } else {
                    indexArr[0] = i;
                    indexArr[1] = i + 1;
                    indexArr[2] = i + 2;
                }
                const { a: a, b: b, c: c } = $d5b85d29c0b78636$var$_triangle;
                a.fromBufferAttribute(positionAttr, indexArr[0]);
                b.fromBufferAttribute(positionAttr, indexArr[1]);
                c.fromBufferAttribute(positionAttr, indexArr[2]);
                $d5b85d29c0b78636$var$_triangle.getNormal($d5b85d29c0b78636$var$_normal);
                // create hashes for the edge from the vertices
                hashes[0] = `${Math.round(a.x * precision)},${Math.round(a.y * precision)},${Math.round(a.z * precision)}`;
                hashes[1] = `${Math.round(b.x * precision)},${Math.round(b.y * precision)},${Math.round(b.z * precision)}`;
                hashes[2] = `${Math.round(c.x * precision)},${Math.round(c.y * precision)},${Math.round(c.z * precision)}`;
                // skip degenerate triangles
                if (hashes[0] === hashes[1] || hashes[1] === hashes[2] || hashes[2] === hashes[0]) continue;
                // iterate over every edge
                for(let j = 0; j < 3; j++){
                    // get the first and next vertex making up the edge
                    const jNext = (j + 1) % 3;
                    const vecHash0 = hashes[j];
                    const vecHash1 = hashes[jNext];
                    const v0 = $d5b85d29c0b78636$var$_triangle[vertKeys[j]];
                    const v1 = $d5b85d29c0b78636$var$_triangle[vertKeys[jNext]];
                    const hash = `${vecHash0}_${vecHash1}`;
                    const reverseHash = `${vecHash1}_${vecHash0}`;
                    if (reverseHash in edgeData && edgeData[reverseHash]) {
                        // if we found a sibling edge add it into the vertex array if
                        // it meets the angle threshold and delete the edge from the map.
                        if ($d5b85d29c0b78636$var$_normal.dot(edgeData[reverseHash].normal) <= thresholdDot) {
                            vertices.push(v0.x, v0.y, v0.z);
                            vertices.push(v1.x, v1.y, v1.z);
                        }
                        edgeData[reverseHash] = null;
                    } else if (!(hash in edgeData)) // if we've already got an edge here then skip adding a new one
                    edgeData[hash] = {
                        index0: indexArr[j],
                        index1: indexArr[jNext],
                        normal: $d5b85d29c0b78636$var$_normal.clone()
                    };
                }
            }
            // iterate over all remaining, unmatched edges and add them to the vertex array
            for(const key in edgeData)if (edgeData[key]) {
                const { index0: index0, index1: index1 } = edgeData[key];
                $d5b85d29c0b78636$var$_v0.fromBufferAttribute(positionAttr, index0);
                $d5b85d29c0b78636$var$_v1$1.fromBufferAttribute(positionAttr, index1);
                vertices.push($d5b85d29c0b78636$var$_v0.x, $d5b85d29c0b78636$var$_v0.y, $d5b85d29c0b78636$var$_v0.z);
                vertices.push($d5b85d29c0b78636$var$_v1$1.x, $d5b85d29c0b78636$var$_v1$1.y, $d5b85d29c0b78636$var$_v1$1.z);
            }
            this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
}
class $d5b85d29c0b78636$export$6428a7f2611ef1fa extends $d5b85d29c0b78636$export$4b2950bdac9b6ee9 {
    constructor(points){
        super(points);
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        this.type = 'Shape';
        this.holes = [];
    }
    getPointsHoles(divisions) {
        const holesPts = [];
        for(let i = 0, l = this.holes.length; i < l; i++)holesPts[i] = this.holes[i].getPoints(divisions);
        return holesPts;
    }
    // get points of shape and holes (keypoints based on segments parameter)
    extractPoints(divisions) {
        return {
            shape: this.getPoints(divisions),
            holes: this.getPointsHoles(divisions)
        };
    }
    copy(source) {
        super.copy(source);
        this.holes = [];
        for(let i = 0, l = source.holes.length; i < l; i++){
            const hole = source.holes[i];
            this.holes.push(hole.clone());
        }
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.uuid = this.uuid;
        data.holes = [];
        for(let i = 0, l = this.holes.length; i < l; i++){
            const hole = this.holes[i];
            data.holes.push(hole.toJSON());
        }
        return data;
    }
    fromJSON(json) {
        super.fromJSON(json);
        this.uuid = json.uuid;
        this.holes = [];
        for(let i = 0, l = json.holes.length; i < l; i++){
            const hole = json.holes[i];
            this.holes.push(new $d5b85d29c0b78636$export$4b2950bdac9b6ee9().fromJSON(hole));
        }
        return this;
    }
}
/**
 * Port from https://github.com/mapbox/earcut (v2.2.4)
 */ const $d5b85d29c0b78636$var$Earcut = {
    triangulate: function(data, holeIndices, dim = 2) {
        const hasHoles = holeIndices && holeIndices.length;
        const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
        let outerNode = $d5b85d29c0b78636$var$linkedList(data, 0, outerLen, dim, true);
        const triangles = [];
        if (!outerNode || outerNode.next === outerNode.prev) return triangles;
        let minX, minY, maxX, maxY, x, y, invSize;
        if (hasHoles) outerNode = $d5b85d29c0b78636$var$eliminateHoles(data, holeIndices, outerNode, dim);
        // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
        if (data.length > 80 * dim) {
            minX = maxX = data[0];
            minY = maxY = data[1];
            for(let i = dim; i < outerLen; i += dim){
                x = data[i];
                y = data[i + 1];
                if (x < minX) minX = x;
                if (y < minY) minY = y;
                if (x > maxX) maxX = x;
                if (y > maxY) maxY = y;
            }
            // minX, minY and invSize are later used to transform coords into integers for z-order calculation
            invSize = Math.max(maxX - minX, maxY - minY);
            invSize = invSize !== 0 ? 32767 / invSize : 0;
        }
        $d5b85d29c0b78636$var$earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
        return triangles;
    }
};
// create a circular doubly linked list from polygon points in the specified winding order
function $d5b85d29c0b78636$var$linkedList(data, start, end, dim, clockwise) {
    let i, last;
    if (clockwise === $d5b85d29c0b78636$var$signedArea(data, start, end, dim) > 0) for(i = start; i < end; i += dim)last = $d5b85d29c0b78636$var$insertNode(i, data[i], data[i + 1], last);
    else for(i = end - dim; i >= start; i -= dim)last = $d5b85d29c0b78636$var$insertNode(i, data[i], data[i + 1], last);
    if (last && $d5b85d29c0b78636$var$equals(last, last.next)) {
        $d5b85d29c0b78636$var$removeNode(last);
        last = last.next;
    }
    return last;
}
// eliminate colinear or duplicate points
function $d5b85d29c0b78636$var$filterPoints(start, end) {
    if (!start) return start;
    if (!end) end = start;
    let p = start, again;
    do {
        again = false;
        if (!p.steiner && ($d5b85d29c0b78636$var$equals(p, p.next) || $d5b85d29c0b78636$var$area(p.prev, p, p.next) === 0)) {
            $d5b85d29c0b78636$var$removeNode(p);
            p = end = p.prev;
            if (p === p.next) break;
            again = true;
        } else p = p.next;
    }while (again || p !== end);
    return end;
}
// main ear slicing loop which triangulates a polygon (given as a linked list)
function $d5b85d29c0b78636$var$earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
    if (!ear) return;
    // interlink polygon nodes in z-order
    if (!pass && invSize) $d5b85d29c0b78636$var$indexCurve(ear, minX, minY, invSize);
    let stop = ear, prev, next;
    // iterate through ears, slicing them one by one
    while(ear.prev !== ear.next){
        prev = ear.prev;
        next = ear.next;
        if (invSize ? $d5b85d29c0b78636$var$isEarHashed(ear, minX, minY, invSize) : $d5b85d29c0b78636$var$isEar(ear)) {
            // cut off the triangle
            triangles.push(prev.i / dim | 0);
            triangles.push(ear.i / dim | 0);
            triangles.push(next.i / dim | 0);
            $d5b85d29c0b78636$var$removeNode(ear);
            // skipping the next vertex leads to less sliver triangles
            ear = next.next;
            stop = next.next;
            continue;
        }
        ear = next;
        // if we looped through the whole remaining polygon and can't find any more ears
        if (ear === stop) {
            // try filtering points and slicing again
            if (!pass) $d5b85d29c0b78636$var$earcutLinked($d5b85d29c0b78636$var$filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
            else if (pass === 1) {
                ear = $d5b85d29c0b78636$var$cureLocalIntersections($d5b85d29c0b78636$var$filterPoints(ear), triangles, dim);
                $d5b85d29c0b78636$var$earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
            // as a last resort, try splitting the remaining polygon into two
            } else if (pass === 2) $d5b85d29c0b78636$var$splitEarcut(ear, triangles, dim, minX, minY, invSize);
            break;
        }
    }
}
// check whether a polygon node forms a valid ear with adjacent nodes
function $d5b85d29c0b78636$var$isEar(ear) {
    const a = ear.prev, b = ear, c = ear.next;
    if ($d5b85d29c0b78636$var$area(a, b, c) >= 0) return false; // reflex, can't be an ear
    // now make sure we don't have other points inside the potential ear
    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
    // triangle bbox; min & max are calculated like this for speed
    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
    let p = c.next;
    while(p !== a){
        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && $d5b85d29c0b78636$var$pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && $d5b85d29c0b78636$var$area(p.prev, p, p.next) >= 0) return false;
        p = p.next;
    }
    return true;
}
function $d5b85d29c0b78636$var$isEarHashed(ear, minX, minY, invSize) {
    const a = ear.prev, b = ear, c = ear.next;
    if ($d5b85d29c0b78636$var$area(a, b, c) >= 0) return false; // reflex, can't be an ear
    const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
    // triangle bbox; min & max are calculated like this for speed
    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx, y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy, x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx, y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
    // z-order range for the current triangle bbox;
    const minZ = $d5b85d29c0b78636$var$zOrder(x0, y0, minX, minY, invSize), maxZ = $d5b85d29c0b78636$var$zOrder(x1, y1, minX, minY, invSize);
    let p = ear.prevZ, n = ear.nextZ;
    // look for points inside the triangle in both directions
    while(p && p.z >= minZ && n && n.z <= maxZ){
        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && $d5b85d29c0b78636$var$pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && $d5b85d29c0b78636$var$area(p.prev, p, p.next) >= 0) return false;
        p = p.prevZ;
        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && $d5b85d29c0b78636$var$pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && $d5b85d29c0b78636$var$area(n.prev, n, n.next) >= 0) return false;
        n = n.nextZ;
    }
    // look for remaining points in decreasing z-order
    while(p && p.z >= minZ){
        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && $d5b85d29c0b78636$var$pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && $d5b85d29c0b78636$var$area(p.prev, p, p.next) >= 0) return false;
        p = p.prevZ;
    }
    // look for remaining points in increasing z-order
    while(n && n.z <= maxZ){
        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && $d5b85d29c0b78636$var$pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && $d5b85d29c0b78636$var$area(n.prev, n, n.next) >= 0) return false;
        n = n.nextZ;
    }
    return true;
}
// go through all polygon nodes and cure small local self-intersections
function $d5b85d29c0b78636$var$cureLocalIntersections(start, triangles, dim) {
    let p = start;
    do {
        const a = p.prev, b = p.next.next;
        if (!$d5b85d29c0b78636$var$equals(a, b) && $d5b85d29c0b78636$var$intersects(a, p, p.next, b) && $d5b85d29c0b78636$var$locallyInside(a, b) && $d5b85d29c0b78636$var$locallyInside(b, a)) {
            triangles.push(a.i / dim | 0);
            triangles.push(p.i / dim | 0);
            triangles.push(b.i / dim | 0);
            // remove two nodes involved
            $d5b85d29c0b78636$var$removeNode(p);
            $d5b85d29c0b78636$var$removeNode(p.next);
            p = start = b;
        }
        p = p.next;
    }while (p !== start);
    return $d5b85d29c0b78636$var$filterPoints(p);
}
// try splitting polygon into two and triangulate them independently
function $d5b85d29c0b78636$var$splitEarcut(start, triangles, dim, minX, minY, invSize) {
    // look for a valid diagonal that divides the polygon into two
    let a = start;
    do {
        let b = a.next.next;
        while(b !== a.prev){
            if (a.i !== b.i && $d5b85d29c0b78636$var$isValidDiagonal(a, b)) {
                // split the polygon in two by the diagonal
                let c = $d5b85d29c0b78636$var$splitPolygon(a, b);
                // filter colinear points around the cuts
                a = $d5b85d29c0b78636$var$filterPoints(a, a.next);
                c = $d5b85d29c0b78636$var$filterPoints(c, c.next);
                // run earcut on each half
                $d5b85d29c0b78636$var$earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
                $d5b85d29c0b78636$var$earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
                return;
            }
            b = b.next;
        }
        a = a.next;
    }while (a !== start);
}
// link every hole into the outer loop, producing a single-ring polygon without holes
function $d5b85d29c0b78636$var$eliminateHoles(data, holeIndices, outerNode, dim) {
    const queue = [];
    let i, len, start, end, list;
    for(i = 0, len = holeIndices.length; i < len; i++){
        start = holeIndices[i] * dim;
        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
        list = $d5b85d29c0b78636$var$linkedList(data, start, end, dim, false);
        if (list === list.next) list.steiner = true;
        queue.push($d5b85d29c0b78636$var$getLeftmost(list));
    }
    queue.sort($d5b85d29c0b78636$var$compareX);
    // process holes from left to right
    for(i = 0; i < queue.length; i++)outerNode = $d5b85d29c0b78636$var$eliminateHole(queue[i], outerNode);
    return outerNode;
}
function $d5b85d29c0b78636$var$compareX(a, b) {
    return a.x - b.x;
}
// find a bridge between vertices that connects hole with an outer ring and link it
function $d5b85d29c0b78636$var$eliminateHole(hole, outerNode) {
    const bridge = $d5b85d29c0b78636$var$findHoleBridge(hole, outerNode);
    if (!bridge) return outerNode;
    const bridgeReverse = $d5b85d29c0b78636$var$splitPolygon(bridge, hole);
    // filter collinear points around the cuts
    $d5b85d29c0b78636$var$filterPoints(bridgeReverse, bridgeReverse.next);
    return $d5b85d29c0b78636$var$filterPoints(bridge, bridge.next);
}
// David Eberly's algorithm for finding a bridge between hole and outer polygon
function $d5b85d29c0b78636$var$findHoleBridge(hole, outerNode) {
    let p = outerNode, qx = -Infinity, m;
    const hx = hole.x, hy = hole.y;
    // find a segment intersected by a ray from the hole's leftmost point to the left;
    // segment's endpoint with lesser x will be potential connection point
    do {
        if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
            const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
            if (x <= hx && x > qx) {
                qx = x;
                m = p.x < p.next.x ? p : p.next;
                if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
            }
        }
        p = p.next;
    }while (p !== outerNode);
    if (!m) return null;
    // look for points inside the triangle of hole point, segment intersection and endpoint;
    // if there are no points found, we have a valid connection;
    // otherwise choose the point of the minimum angle with the ray as connection point
    const stop = m, mx = m.x, my = m.y;
    let tanMin = Infinity, tan;
    p = m;
    do {
        if (hx >= p.x && p.x >= mx && hx !== p.x && $d5b85d29c0b78636$var$pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
            tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
            if ($d5b85d29c0b78636$var$locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && $d5b85d29c0b78636$var$sectorContainsSector(m, p)))) {
                m = p;
                tanMin = tan;
            }
        }
        p = p.next;
    }while (p !== stop);
    return m;
}
// whether sector in vertex m contains sector in vertex p in the same coordinates
function $d5b85d29c0b78636$var$sectorContainsSector(m, p) {
    return $d5b85d29c0b78636$var$area(m.prev, m, p.prev) < 0 && $d5b85d29c0b78636$var$area(p.next, m, m.next) < 0;
}
// interlink polygon nodes in z-order
function $d5b85d29c0b78636$var$indexCurve(start, minX, minY, invSize) {
    let p = start;
    do {
        if (p.z === 0) p.z = $d5b85d29c0b78636$var$zOrder(p.x, p.y, minX, minY, invSize);
        p.prevZ = p.prev;
        p.nextZ = p.next;
        p = p.next;
    }while (p !== start);
    p.prevZ.nextZ = null;
    p.prevZ = null;
    $d5b85d29c0b78636$var$sortLinked(p);
}
// Simon Tatham's linked list merge sort algorithm
// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
function $d5b85d29c0b78636$var$sortLinked(list) {
    let i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
    do {
        p = list;
        list = null;
        tail = null;
        numMerges = 0;
        while(p){
            numMerges++;
            q = p;
            pSize = 0;
            for(i = 0; i < inSize; i++){
                pSize++;
                q = q.nextZ;
                if (!q) break;
            }
            qSize = inSize;
            while(pSize > 0 || qSize > 0 && q){
                if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
                    e = p;
                    p = p.nextZ;
                    pSize--;
                } else {
                    e = q;
                    q = q.nextZ;
                    qSize--;
                }
                if (tail) tail.nextZ = e;
                else list = e;
                e.prevZ = tail;
                tail = e;
            }
            p = q;
        }
        tail.nextZ = null;
        inSize *= 2;
    }while (numMerges > 1);
    return list;
}
// z-order of a point given coords and inverse of the longer side of data bbox
function $d5b85d29c0b78636$var$zOrder(x, y, minX, minY, invSize) {
    // coords are transformed into non-negative 15-bit integer range
    x = (x - minX) * invSize | 0;
    y = (y - minY) * invSize | 0;
    x = (x | x << 8) & 0x00FF00FF;
    x = (x | x << 4) & 0x0F0F0F0F;
    x = (x | x << 2) & 0x33333333;
    x = (x | x << 1) & 0x55555555;
    y = (y | y << 8) & 0x00FF00FF;
    y = (y | y << 4) & 0x0F0F0F0F;
    y = (y | y << 2) & 0x33333333;
    y = (y | y << 1) & 0x55555555;
    return x | y << 1;
}
// find the leftmost node of a polygon ring
function $d5b85d29c0b78636$var$getLeftmost(start) {
    let p = start, leftmost = start;
    do {
        if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y) leftmost = p;
        p = p.next;
    }while (p !== start);
    return leftmost;
}
// check if a point lies within a convex triangle
function $d5b85d29c0b78636$var$pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
}
// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
function $d5b85d29c0b78636$var$isValidDiagonal(a, b) {
    return a.next.i !== b.i && a.prev.i !== b.i && !$d5b85d29c0b78636$var$intersectsPolygon(a, b) && // doesn't intersect other edges
    ($d5b85d29c0b78636$var$locallyInside(a, b) && $d5b85d29c0b78636$var$locallyInside(b, a) && $d5b85d29c0b78636$var$middleInside(a, b) && // locally visible
    ($d5b85d29c0b78636$var$area(a.prev, a, b.prev) || $d5b85d29c0b78636$var$area(a, b.prev, b)) || // does not create opposite-facing sectors
    $d5b85d29c0b78636$var$equals(a, b) && $d5b85d29c0b78636$var$area(a.prev, a, a.next) > 0 && $d5b85d29c0b78636$var$area(b.prev, b, b.next) > 0); // special zero-length case
}
// signed area of a triangle
function $d5b85d29c0b78636$var$area(p, q, r) {
    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
}
// check if two points are equal
function $d5b85d29c0b78636$var$equals(p1, p2) {
    return p1.x === p2.x && p1.y === p2.y;
}
// check if two segments intersect
function $d5b85d29c0b78636$var$intersects(p1, q1, p2, q2) {
    const o1 = $d5b85d29c0b78636$var$sign($d5b85d29c0b78636$var$area(p1, q1, p2));
    const o2 = $d5b85d29c0b78636$var$sign($d5b85d29c0b78636$var$area(p1, q1, q2));
    const o3 = $d5b85d29c0b78636$var$sign($d5b85d29c0b78636$var$area(p2, q2, p1));
    const o4 = $d5b85d29c0b78636$var$sign($d5b85d29c0b78636$var$area(p2, q2, q1));
    if (o1 !== o2 && o3 !== o4) return true; // general case
    if (o1 === 0 && $d5b85d29c0b78636$var$onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
    if (o2 === 0 && $d5b85d29c0b78636$var$onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
    if (o3 === 0 && $d5b85d29c0b78636$var$onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
    if (o4 === 0 && $d5b85d29c0b78636$var$onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
    return false;
}
// for collinear points p, q, r, check if point q lies on segment pr
function $d5b85d29c0b78636$var$onSegment(p, q, r) {
    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
}
function $d5b85d29c0b78636$var$sign(num) {
    return num > 0 ? 1 : num < 0 ? -1 : 0;
}
// check if a polygon diagonal intersects any polygon segments
function $d5b85d29c0b78636$var$intersectsPolygon(a, b) {
    let p = a;
    do {
        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && $d5b85d29c0b78636$var$intersects(p, p.next, a, b)) return true;
        p = p.next;
    }while (p !== a);
    return false;
}
// check if a polygon diagonal is locally inside the polygon
function $d5b85d29c0b78636$var$locallyInside(a, b) {
    return $d5b85d29c0b78636$var$area(a.prev, a, a.next) < 0 ? $d5b85d29c0b78636$var$area(a, b, a.next) >= 0 && $d5b85d29c0b78636$var$area(a, a.prev, b) >= 0 : $d5b85d29c0b78636$var$area(a, b, a.prev) < 0 || $d5b85d29c0b78636$var$area(a, a.next, b) < 0;
}
// check if the middle point of a polygon diagonal is inside the polygon
function $d5b85d29c0b78636$var$middleInside(a, b) {
    let p = a, inside = false;
    const px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
    do {
        if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x) inside = !inside;
        p = p.next;
    }while (p !== a);
    return inside;
}
// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
// if one belongs to the outer ring and another to a hole, it merges it into a single ring
function $d5b85d29c0b78636$var$splitPolygon(a, b) {
    const a2 = new $d5b85d29c0b78636$var$Node(a.i, a.x, a.y), b2 = new $d5b85d29c0b78636$var$Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
    a.next = b;
    b.prev = a;
    a2.next = an;
    an.prev = a2;
    b2.next = a2;
    a2.prev = b2;
    bp.next = b2;
    b2.prev = bp;
    return b2;
}
// create a node and optionally link it with previous one (in a circular doubly linked list)
function $d5b85d29c0b78636$var$insertNode(i, x, y, last) {
    const p = new $d5b85d29c0b78636$var$Node(i, x, y);
    if (!last) {
        p.prev = p;
        p.next = p;
    } else {
        p.next = last.next;
        p.prev = last;
        last.next.prev = p;
        last.next = p;
    }
    return p;
}
function $d5b85d29c0b78636$var$removeNode(p) {
    p.next.prev = p.prev;
    p.prev.next = p.next;
    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
}
function $d5b85d29c0b78636$var$Node(i, x, y) {
    // vertex index in coordinates array
    this.i = i;
    // vertex coordinates
    this.x = x;
    this.y = y;
    // previous and next vertex nodes in a polygon ring
    this.prev = null;
    this.next = null;
    // z-order curve value
    this.z = 0;
    // previous and next nodes in z-order
    this.prevZ = null;
    this.nextZ = null;
    // indicates whether this is a steiner point
    this.steiner = false;
}
function $d5b85d29c0b78636$var$signedArea(data, start, end, dim) {
    let sum = 0;
    for(let i = start, j = end - dim; i < end; i += dim){
        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
        j = i;
    }
    return sum;
}
class $d5b85d29c0b78636$export$96bdf6d9c66d7ba8 {
    // calculate area of the contour polygon
    static area(contour) {
        const n = contour.length;
        let a = 0.0;
        for(let p = n - 1, q = 0; q < n; p = q++)a += contour[p].x * contour[q].y - contour[q].x * contour[p].y;
        return a * 0.5;
    }
    static isClockWise(pts) {
        return $d5b85d29c0b78636$export$96bdf6d9c66d7ba8.area(pts) < 0;
    }
    static triangulateShape(contour, holes) {
        const vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]
        const holeIndices = []; // array of hole indices
        const faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]
        $d5b85d29c0b78636$var$removeDupEndPts(contour);
        $d5b85d29c0b78636$var$addContour(vertices, contour);
        //
        let holeIndex = contour.length;
        holes.forEach($d5b85d29c0b78636$var$removeDupEndPts);
        for(let i = 0; i < holes.length; i++){
            holeIndices.push(holeIndex);
            holeIndex += holes[i].length;
            $d5b85d29c0b78636$var$addContour(vertices, holes[i]);
        }
        //
        const triangles = $d5b85d29c0b78636$var$Earcut.triangulate(vertices, holeIndices);
        //
        for(let i = 0; i < triangles.length; i += 3)faces.push(triangles.slice(i, i + 3));
        return faces;
    }
}
function $d5b85d29c0b78636$var$removeDupEndPts(points) {
    const l = points.length;
    if (l > 2 && points[l - 1].equals(points[0])) points.pop();
}
function $d5b85d29c0b78636$var$addContour(vertices, contour) {
    for(let i = 0; i < contour.length; i++){
        vertices.push(contour[i].x);
        vertices.push(contour[i].y);
    }
}
/**
 * Creates extruded geometry from a path shape.
 *
 * parameters = {
 *
 *  curveSegments: <int>, // number of points on the curves
 *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too
 *  depth: <float>, // Depth to extrude the shape
 *
 *  bevelEnabled: <bool>, // turn on bevel
 *  bevelThickness: <float>, // how deep into the original shape bevel goes
 *  bevelSize: <float>, // how far from shape outline (including bevelOffset) is bevel
 *  bevelOffset: <float>, // how far from shape outline does bevel start
 *  bevelSegments: <int>, // number of bevel layers
 *
 *  extrudePath: <THREE.Curve> // curve to extrude shape along
 *
 *  UVGenerator: <Object> // object that provides UV generator functions
 *
 * }
 */ class $d5b85d29c0b78636$export$598697a1efa63ca7 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(shapes = new $d5b85d29c0b78636$export$6428a7f2611ef1fa([
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0.5, 0.5),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(-0.5, 0.5),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(-0.5, -0.5),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0.5, -0.5)
    ]), options = {}){
        super();
        this.type = 'ExtrudeGeometry';
        this.parameters = {
            shapes: shapes,
            options: options
        };
        shapes = Array.isArray(shapes) ? shapes : [
            shapes
        ];
        const scope = this;
        const verticesArray = [];
        const uvArray = [];
        for(let i = 0, l = shapes.length; i < l; i++){
            const shape = shapes[i];
            addShape(shape);
        }
        // build geometry
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(verticesArray, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvArray, 2));
        this.computeVertexNormals();
        // functions
        function addShape(shape) {
            const placeholder = [];
            // options
            const curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
            const steps = options.steps !== undefined ? options.steps : 1;
            const depth = options.depth !== undefined ? options.depth : 1;
            let bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true;
            let bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 0.2;
            let bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 0.1;
            let bevelOffset = options.bevelOffset !== undefined ? options.bevelOffset : 0;
            let bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;
            const extrudePath = options.extrudePath;
            const uvgen = options.UVGenerator !== undefined ? options.UVGenerator : $d5b85d29c0b78636$var$WorldUVGenerator;
            //
            let extrudePts, extrudeByPath = false;
            let splineTube, binormal, normal, position2;
            if (extrudePath) {
                extrudePts = extrudePath.getSpacedPoints(steps);
                extrudeByPath = true;
                bevelEnabled = false; // bevels not supported for path extrusion
                // SETUP TNB variables
                // TODO1 - have a .isClosed in spline?
                splineTube = extrudePath.computeFrenetFrames(steps, false);
                // console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);
                binormal = new $d5b85d29c0b78636$export$64b5c384219d3699();
                normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
                position2 = new $d5b85d29c0b78636$export$64b5c384219d3699();
            }
            // Safeguards if bevels are not enabled
            if (!bevelEnabled) {
                bevelSegments = 0;
                bevelThickness = 0;
                bevelSize = 0;
                bevelOffset = 0;
            }
            // Variables initialization
            const shapePoints = shape.extractPoints(curveSegments);
            let vertices = shapePoints.shape;
            const holes = shapePoints.holes;
            const reverse = !$d5b85d29c0b78636$export$96bdf6d9c66d7ba8.isClockWise(vertices);
            if (reverse) {
                vertices = vertices.reverse();
                // Maybe we should also check if holes are in the opposite direction, just to be safe ...
                for(let h = 0, hl = holes.length; h < hl; h++){
                    const ahole = holes[h];
                    if ($d5b85d29c0b78636$export$96bdf6d9c66d7ba8.isClockWise(ahole)) holes[h] = ahole.reverse();
                }
            }
            const faces = $d5b85d29c0b78636$export$96bdf6d9c66d7ba8.triangulateShape(vertices, holes);
            /* Vertices */ const contour = vertices; // vertices has all points but contour has only points of circumference
            for(let h = 0, hl = holes.length; h < hl; h++){
                const ahole = holes[h];
                vertices = vertices.concat(ahole);
            }
            function scalePt2(pt, vec, size) {
                if (!vec) console.error('THREE.ExtrudeGeometry: vec does not exist');
                return pt.clone().addScaledVector(vec, size);
            }
            const vlen = vertices.length, flen = faces.length;
            // Find directions for point movement
            function getBevelVec(inPt, inPrev, inNext) {
                // computes for inPt the corresponding point inPt' on a new contour
                //   shifted by 1 unit (length of normalized vector) to the left
                // if we walk along contour clockwise, this new contour is outside the old one
                //
                // inPt' is the intersection of the two lines parallel to the two
                //  adjacent edges of inPt at a distance of 1 unit on the left side.
                let v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt
                // good reading for geometry algorithms (here: line-line intersection)
                // http://geomalgorithms.com/a05-_intersect-1.html
                const v_prev_x = inPt.x - inPrev.x, v_prev_y = inPt.y - inPrev.y;
                const v_next_x = inNext.x - inPt.x, v_next_y = inNext.y - inPt.y;
                const v_prev_lensq = v_prev_x * v_prev_x + v_prev_y * v_prev_y;
                // check for collinear edges
                const collinear0 = v_prev_x * v_next_y - v_prev_y * v_next_x;
                if (Math.abs(collinear0) > Number.EPSILON) {
                    // not collinear
                    // length of vectors for normalizing
                    const v_prev_len = Math.sqrt(v_prev_lensq);
                    const v_next_len = Math.sqrt(v_next_x * v_next_x + v_next_y * v_next_y);
                    // shift adjacent points by unit vectors to the left
                    const ptPrevShift_x = inPrev.x - v_prev_y / v_prev_len;
                    const ptPrevShift_y = inPrev.y + v_prev_x / v_prev_len;
                    const ptNextShift_x = inNext.x - v_next_y / v_next_len;
                    const ptNextShift_y = inNext.y + v_next_x / v_next_len;
                    // scaling factor for v_prev to intersection point
                    const sf = ((ptNextShift_x - ptPrevShift_x) * v_next_y - (ptNextShift_y - ptPrevShift_y) * v_next_x) / (v_prev_x * v_next_y - v_prev_y * v_next_x);
                    // vector from inPt to intersection point
                    v_trans_x = ptPrevShift_x + v_prev_x * sf - inPt.x;
                    v_trans_y = ptPrevShift_y + v_prev_y * sf - inPt.y;
                    // Don't normalize!, otherwise sharp corners become ugly
                    //  but prevent crazy spikes
                    const v_trans_lensq = v_trans_x * v_trans_x + v_trans_y * v_trans_y;
                    if (v_trans_lensq <= 2) return new $d5b85d29c0b78636$export$c977b3e384af9ae1(v_trans_x, v_trans_y);
                    else shrink_by = Math.sqrt(v_trans_lensq / 2);
                } else {
                    // handle special case of collinear edges
                    let direction_eq = false; // assumes: opposite
                    if (v_prev_x > Number.EPSILON) {
                        if (v_next_x > Number.EPSILON) direction_eq = true;
                    } else {
                        if (v_prev_x < -Number.EPSILON) {
                            if (v_next_x < -Number.EPSILON) direction_eq = true;
                        } else if (Math.sign(v_prev_y) === Math.sign(v_next_y)) direction_eq = true;
                    }
                    if (direction_eq) {
                        // console.log("Warning: lines are a straight sequence");
                        v_trans_x = -v_prev_y;
                        v_trans_y = v_prev_x;
                        shrink_by = Math.sqrt(v_prev_lensq);
                    } else {
                        // console.log("Warning: lines are a straight spike");
                        v_trans_x = v_prev_x;
                        v_trans_y = v_prev_y;
                        shrink_by = Math.sqrt(v_prev_lensq / 2);
                    }
                }
                return new $d5b85d29c0b78636$export$c977b3e384af9ae1(v_trans_x / shrink_by, v_trans_y / shrink_by);
            }
            const contourMovements = [];
            for(let i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i++, j++, k++){
                if (j === il) j = 0;
                if (k === il) k = 0;
                //  (j)---(i)---(k)
                // console.log('i,j,k', i, j , k)
                contourMovements[i] = getBevelVec(contour[i], contour[j], contour[k]);
            }
            const holesMovements = [];
            let oneHoleMovements, verticesMovements = contourMovements.concat();
            for(let h = 0, hl = holes.length; h < hl; h++){
                const ahole = holes[h];
                oneHoleMovements = [];
                for(let i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i++, j++, k++){
                    if (j === il) j = 0;
                    if (k === il) k = 0;
                    //  (j)---(i)---(k)
                    oneHoleMovements[i] = getBevelVec(ahole[i], ahole[j], ahole[k]);
                }
                holesMovements.push(oneHoleMovements);
                verticesMovements = verticesMovements.concat(oneHoleMovements);
            }
            // Loop bevelSegments, 1 for the front, 1 for the back
            for(let b = 0; b < bevelSegments; b++){
                //for ( b = bevelSegments; b > 0; b -- ) {
                const t = b / bevelSegments;
                const z = bevelThickness * Math.cos(t * Math.PI / 2);
                const bs = bevelSize * Math.sin(t * Math.PI / 2) + bevelOffset;
                // contract shape
                for(let i = 0, il = contour.length; i < il; i++){
                    const vert = scalePt2(contour[i], contourMovements[i], bs);
                    v(vert.x, vert.y, -z);
                }
                // expand holes
                for(let h = 0, hl = holes.length; h < hl; h++){
                    const ahole = holes[h];
                    oneHoleMovements = holesMovements[h];
                    for(let i = 0, il = ahole.length; i < il; i++){
                        const vert = scalePt2(ahole[i], oneHoleMovements[i], bs);
                        v(vert.x, vert.y, -z);
                    }
                }
            }
            const bs = bevelSize + bevelOffset;
            // Back facing vertices
            for(let i = 0; i < vlen; i++){
                const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
                if (!extrudeByPath) v(vert.x, vert.y, 0);
                else {
                    // v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );
                    normal.copy(splineTube.normals[0]).multiplyScalar(vert.x);
                    binormal.copy(splineTube.binormals[0]).multiplyScalar(vert.y);
                    position2.copy(extrudePts[0]).add(normal).add(binormal);
                    v(position2.x, position2.y, position2.z);
                }
            }
            // Add stepped vertices...
            // Including front facing vertices
            for(let s = 1; s <= steps; s++)for(let i = 0; i < vlen; i++){
                const vert = bevelEnabled ? scalePt2(vertices[i], verticesMovements[i], bs) : vertices[i];
                if (!extrudeByPath) v(vert.x, vert.y, depth / steps * s);
                else {
                    // v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );
                    normal.copy(splineTube.normals[s]).multiplyScalar(vert.x);
                    binormal.copy(splineTube.binormals[s]).multiplyScalar(vert.y);
                    position2.copy(extrudePts[s]).add(normal).add(binormal);
                    v(position2.x, position2.y, position2.z);
                }
            }
            // Add bevel segments planes
            //for ( b = 1; b <= bevelSegments; b ++ ) {
            for(let b = bevelSegments - 1; b >= 0; b--){
                const t = b / bevelSegments;
                const z = bevelThickness * Math.cos(t * Math.PI / 2);
                const bs = bevelSize * Math.sin(t * Math.PI / 2) + bevelOffset;
                // contract shape
                for(let i = 0, il = contour.length; i < il; i++){
                    const vert = scalePt2(contour[i], contourMovements[i], bs);
                    v(vert.x, vert.y, depth + z);
                }
                // expand holes
                for(let h = 0, hl = holes.length; h < hl; h++){
                    const ahole = holes[h];
                    oneHoleMovements = holesMovements[h];
                    for(let i = 0, il = ahole.length; i < il; i++){
                        const vert = scalePt2(ahole[i], oneHoleMovements[i], bs);
                        if (!extrudeByPath) v(vert.x, vert.y, depth + z);
                        else v(vert.x, vert.y + extrudePts[steps - 1].y, extrudePts[steps - 1].x + z);
                    }
                }
            }
            /* Faces */ // Top and bottom faces
            buildLidFaces();
            // Sides faces
            buildSideFaces();
            /////  Internal functions
            function buildLidFaces() {
                const start = verticesArray.length / 3;
                if (bevelEnabled) {
                    let layer = 0; // steps + 1
                    let offset = vlen * layer;
                    // Bottom faces
                    for(let i = 0; i < flen; i++){
                        const face = faces[i];
                        f3(face[2] + offset, face[1] + offset, face[0] + offset);
                    }
                    layer = steps + bevelSegments * 2;
                    offset = vlen * layer;
                    // Top faces
                    for(let i = 0; i < flen; i++){
                        const face = faces[i];
                        f3(face[0] + offset, face[1] + offset, face[2] + offset);
                    }
                } else {
                    // Bottom faces
                    for(let i = 0; i < flen; i++){
                        const face = faces[i];
                        f3(face[2], face[1], face[0]);
                    }
                    // Top faces
                    for(let i = 0; i < flen; i++){
                        const face = faces[i];
                        f3(face[0] + vlen * steps, face[1] + vlen * steps, face[2] + vlen * steps);
                    }
                }
                scope.addGroup(start, verticesArray.length / 3 - start, 0);
            }
            // Create faces for the z-sides of the shape
            function buildSideFaces() {
                const start = verticesArray.length / 3;
                let layeroffset = 0;
                sidewalls(contour, layeroffset);
                layeroffset += contour.length;
                for(let h = 0, hl = holes.length; h < hl; h++){
                    const ahole = holes[h];
                    sidewalls(ahole, layeroffset);
                    //, true
                    layeroffset += ahole.length;
                }
                scope.addGroup(start, verticesArray.length / 3 - start, 1);
            }
            function sidewalls(contour, layeroffset) {
                let i = contour.length;
                while(--i >= 0){
                    const j = i;
                    let k = i - 1;
                    if (k < 0) k = contour.length - 1;
                    //console.log('b', i,j, i-1, k,vertices.length);
                    for(let s = 0, sl = steps + bevelSegments * 2; s < sl; s++){
                        const slen1 = vlen * s;
                        const slen2 = vlen * (s + 1);
                        const a = layeroffset + j + slen1, b = layeroffset + k + slen1, c = layeroffset + k + slen2, d = layeroffset + j + slen2;
                        f4(a, b, c, d);
                    }
                }
            }
            function v(x, y, z) {
                placeholder.push(x);
                placeholder.push(y);
                placeholder.push(z);
            }
            function f3(a, b, c) {
                addVertex(a);
                addVertex(b);
                addVertex(c);
                const nextIndex = verticesArray.length / 3;
                const uvs = uvgen.generateTopUV(scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1);
                addUV(uvs[0]);
                addUV(uvs[1]);
                addUV(uvs[2]);
            }
            function f4(a, b, c, d) {
                addVertex(a);
                addVertex(b);
                addVertex(d);
                addVertex(b);
                addVertex(c);
                addVertex(d);
                const nextIndex = verticesArray.length / 3;
                const uvs = uvgen.generateSideWallUV(scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1);
                addUV(uvs[0]);
                addUV(uvs[1]);
                addUV(uvs[3]);
                addUV(uvs[1]);
                addUV(uvs[2]);
                addUV(uvs[3]);
            }
            function addVertex(index) {
                verticesArray.push(placeholder[index * 3 + 0]);
                verticesArray.push(placeholder[index * 3 + 1]);
                verticesArray.push(placeholder[index * 3 + 2]);
            }
            function addUV(vector2) {
                uvArray.push(vector2.x);
                uvArray.push(vector2.y);
            }
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        const shapes = this.parameters.shapes;
        const options = this.parameters.options;
        return $d5b85d29c0b78636$var$toJSON$1(shapes, options, data);
    }
    static fromJSON(data, shapes) {
        const geometryShapes = [];
        for(let j = 0, jl = data.shapes.length; j < jl; j++){
            const shape = shapes[data.shapes[j]];
            geometryShapes.push(shape);
        }
        const extrudePath = data.options.extrudePath;
        if (extrudePath !== undefined) data.options.extrudePath = new $d5b85d29c0b78636$var$Curves[extrudePath.type]().fromJSON(extrudePath);
        return new $d5b85d29c0b78636$export$598697a1efa63ca7(geometryShapes, data.options);
    }
}
const $d5b85d29c0b78636$var$WorldUVGenerator = {
    generateTopUV: function(geometry, vertices, indexA, indexB, indexC) {
        const a_x = vertices[indexA * 3];
        const a_y = vertices[indexA * 3 + 1];
        const b_x = vertices[indexB * 3];
        const b_y = vertices[indexB * 3 + 1];
        const c_x = vertices[indexC * 3];
        const c_y = vertices[indexC * 3 + 1];
        return [
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(a_x, a_y),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(b_x, b_y),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(c_x, c_y)
        ];
    },
    generateSideWallUV: function(geometry, vertices, indexA, indexB, indexC, indexD) {
        const a_x = vertices[indexA * 3];
        const a_y = vertices[indexA * 3 + 1];
        const a_z = vertices[indexA * 3 + 2];
        const b_x = vertices[indexB * 3];
        const b_y = vertices[indexB * 3 + 1];
        const b_z = vertices[indexB * 3 + 2];
        const c_x = vertices[indexC * 3];
        const c_y = vertices[indexC * 3 + 1];
        const c_z = vertices[indexC * 3 + 2];
        const d_x = vertices[indexD * 3];
        const d_y = vertices[indexD * 3 + 1];
        const d_z = vertices[indexD * 3 + 2];
        if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) return [
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(a_x, 1 - a_z),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(b_x, 1 - b_z),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(c_x, 1 - c_z),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(d_x, 1 - d_z)
        ];
        else return [
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(a_y, 1 - a_z),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(b_y, 1 - b_z),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(c_y, 1 - c_z),
            new $d5b85d29c0b78636$export$c977b3e384af9ae1(d_y, 1 - d_z)
        ];
    }
};
function $d5b85d29c0b78636$var$toJSON$1(shapes, options, data) {
    data.shapes = [];
    if (Array.isArray(shapes)) for(let i = 0, l = shapes.length; i < l; i++){
        const shape = shapes[i];
        data.shapes.push(shape.uuid);
    }
    else data.shapes.push(shapes.uuid);
    data.options = Object.assign({}, options);
    if (options.extrudePath !== undefined) data.options.extrudePath = options.extrudePath.toJSON();
    return data;
}
class $d5b85d29c0b78636$export$9567cc828c9535da extends $d5b85d29c0b78636$export$60e57a7d3f20ff65 {
    constructor(radius = 1, detail = 0){
        const t = (1 + Math.sqrt(5)) / 2;
        const vertices = [
            -1,
            t,
            0,
            1,
            t,
            0,
            -1,
            -t,
            0,
            1,
            -t,
            0,
            0,
            -1,
            t,
            0,
            1,
            t,
            0,
            -1,
            -t,
            0,
            1,
            -t,
            t,
            0,
            -1,
            t,
            0,
            1,
            -t,
            0,
            -1,
            -t,
            0,
            1
        ];
        const indices = [
            0,
            11,
            5,
            0,
            5,
            1,
            0,
            1,
            7,
            0,
            7,
            10,
            0,
            10,
            11,
            1,
            5,
            9,
            5,
            11,
            4,
            11,
            10,
            2,
            10,
            7,
            6,
            7,
            1,
            8,
            3,
            9,
            4,
            3,
            4,
            2,
            3,
            2,
            6,
            3,
            6,
            8,
            3,
            8,
            9,
            4,
            9,
            5,
            2,
            4,
            11,
            6,
            2,
            10,
            8,
            6,
            7,
            9,
            8,
            1
        ];
        super(vertices, indices, radius, detail);
        this.type = 'IcosahedronGeometry';
        this.parameters = {
            radius: radius,
            detail: detail
        };
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$9567cc828c9535da(data.radius, data.detail);
    }
}
class $d5b85d29c0b78636$export$1954e2b809fe361e extends $d5b85d29c0b78636$export$60e57a7d3f20ff65 {
    constructor(radius = 1, detail = 0){
        const vertices = [
            1,
            0,
            0,
            -1,
            0,
            0,
            0,
            1,
            0,
            0,
            -1,
            0,
            0,
            0,
            1,
            0,
            0,
            -1
        ];
        const indices = [
            0,
            2,
            4,
            0,
            4,
            3,
            0,
            3,
            5,
            0,
            5,
            2,
            1,
            2,
            5,
            1,
            5,
            3,
            1,
            3,
            4,
            1,
            4,
            2
        ];
        super(vertices, indices, radius, detail);
        this.type = 'OctahedronGeometry';
        this.parameters = {
            radius: radius,
            detail: detail
        };
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$1954e2b809fe361e(data.radius, data.detail);
    }
}
class $d5b85d29c0b78636$export$967d831af31f69ce extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(width = 1, height = 1, widthSegments = 1, heightSegments = 1){
        super();
        this.type = 'PlaneGeometry';
        this.parameters = {
            width: width,
            height: height,
            widthSegments: widthSegments,
            heightSegments: heightSegments
        };
        const width_half = width / 2;
        const height_half = height / 2;
        const gridX = Math.floor(widthSegments);
        const gridY = Math.floor(heightSegments);
        const gridX1 = gridX + 1;
        const gridY1 = gridY + 1;
        const segment_width = width / gridX;
        const segment_height = height / gridY;
        //
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        for(let iy = 0; iy < gridY1; iy++){
            const y = iy * segment_height - height_half;
            for(let ix = 0; ix < gridX1; ix++){
                const x = ix * segment_width - width_half;
                vertices.push(x, -y, 0);
                normals.push(0, 0, 1);
                uvs.push(ix / gridX);
                uvs.push(1 - iy / gridY);
            }
        }
        for(let iy = 0; iy < gridY; iy++)for(let ix = 0; ix < gridX; ix++){
            const a = ix + gridX1 * iy;
            const b = ix + gridX1 * (iy + 1);
            const c = ix + 1 + gridX1 * (iy + 1);
            const d = ix + 1 + gridX1 * iy;
            indices.push(a, b, d);
            indices.push(b, c, d);
        }
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$967d831af31f69ce(data.width, data.height, data.widthSegments, data.heightSegments);
    }
}
class $d5b85d29c0b78636$export$68cb731f50f614af extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(innerRadius = 0.5, outerRadius = 1, thetaSegments = 32, phiSegments = 1, thetaStart = 0, thetaLength = Math.PI * 2){
        super();
        this.type = 'RingGeometry';
        this.parameters = {
            innerRadius: innerRadius,
            outerRadius: outerRadius,
            thetaSegments: thetaSegments,
            phiSegments: phiSegments,
            thetaStart: thetaStart,
            thetaLength: thetaLength
        };
        thetaSegments = Math.max(3, thetaSegments);
        phiSegments = Math.max(1, phiSegments);
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // some helper variables
        let radius = innerRadius;
        const radiusStep = (outerRadius - innerRadius) / phiSegments;
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const uv = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
        // generate vertices, normals and uvs
        for(let j = 0; j <= phiSegments; j++){
            for(let i = 0; i <= thetaSegments; i++){
                // values are generate from the inside of the ring to the outside
                const segment = thetaStart + i / thetaSegments * thetaLength;
                // vertex
                vertex.x = radius * Math.cos(segment);
                vertex.y = radius * Math.sin(segment);
                vertices.push(vertex.x, vertex.y, vertex.z);
                // normal
                normals.push(0, 0, 1);
                // uv
                uv.x = (vertex.x / outerRadius + 1) / 2;
                uv.y = (vertex.y / outerRadius + 1) / 2;
                uvs.push(uv.x, uv.y);
            }
            // increase the radius for next row of vertices
            radius += radiusStep;
        }
        // indices
        for(let j = 0; j < phiSegments; j++){
            const thetaSegmentLevel = j * (thetaSegments + 1);
            for(let i = 0; i < thetaSegments; i++){
                const segment = i + thetaSegmentLevel;
                const a = segment;
                const b = segment + thetaSegments + 1;
                const c = segment + thetaSegments + 2;
                const d = segment + 1;
                // faces
                indices.push(a, b, d);
                indices.push(b, c, d);
            }
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$68cb731f50f614af(data.innerRadius, data.outerRadius, data.thetaSegments, data.phiSegments, data.thetaStart, data.thetaLength);
    }
}
class $d5b85d29c0b78636$export$57a29a1c803e9065 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(shapes = new $d5b85d29c0b78636$export$6428a7f2611ef1fa([
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0, 0.5),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(-0.5, -0.5),
        new $d5b85d29c0b78636$export$c977b3e384af9ae1(0.5, -0.5)
    ]), curveSegments = 12){
        super();
        this.type = 'ShapeGeometry';
        this.parameters = {
            shapes: shapes,
            curveSegments: curveSegments
        };
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // helper variables
        let groupStart = 0;
        let groupCount = 0;
        // allow single and array values for "shapes" parameter
        if (Array.isArray(shapes) === false) addShape(shapes);
        else for(let i = 0; i < shapes.length; i++){
            addShape(shapes[i]);
            this.addGroup(groupStart, groupCount, i); // enables MultiMaterial support
            groupStart += groupCount;
            groupCount = 0;
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
        // helper functions
        function addShape(shape) {
            const indexOffset = vertices.length / 3;
            const points = shape.extractPoints(curveSegments);
            let shapeVertices = points.shape;
            const shapeHoles = points.holes;
            // check direction of vertices
            if ($d5b85d29c0b78636$export$96bdf6d9c66d7ba8.isClockWise(shapeVertices) === false) shapeVertices = shapeVertices.reverse();
            for(let i = 0, l = shapeHoles.length; i < l; i++){
                const shapeHole = shapeHoles[i];
                if ($d5b85d29c0b78636$export$96bdf6d9c66d7ba8.isClockWise(shapeHole) === true) shapeHoles[i] = shapeHole.reverse();
            }
            const faces = $d5b85d29c0b78636$export$96bdf6d9c66d7ba8.triangulateShape(shapeVertices, shapeHoles);
            // join vertices of inner and outer paths to a single array
            for(let i = 0, l = shapeHoles.length; i < l; i++){
                const shapeHole = shapeHoles[i];
                shapeVertices = shapeVertices.concat(shapeHole);
            }
            // vertices, normals, uvs
            for(let i = 0, l = shapeVertices.length; i < l; i++){
                const vertex = shapeVertices[i];
                vertices.push(vertex.x, vertex.y, 0);
                normals.push(0, 0, 1);
                uvs.push(vertex.x, vertex.y); // world uvs
            }
            // indices
            for(let i = 0, l = faces.length; i < l; i++){
                const face = faces[i];
                const a = face[0] + indexOffset;
                const b = face[1] + indexOffset;
                const c = face[2] + indexOffset;
                indices.push(a, b, c);
                groupCount += 3;
            }
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        const shapes = this.parameters.shapes;
        return $d5b85d29c0b78636$var$toJSON(shapes, data);
    }
    static fromJSON(data, shapes) {
        const geometryShapes = [];
        for(let j = 0, jl = data.shapes.length; j < jl; j++){
            const shape = shapes[data.shapes[j]];
            geometryShapes.push(shape);
        }
        return new $d5b85d29c0b78636$export$57a29a1c803e9065(geometryShapes, data.curveSegments);
    }
}
function $d5b85d29c0b78636$var$toJSON(shapes, data) {
    data.shapes = [];
    if (Array.isArray(shapes)) for(let i = 0, l = shapes.length; i < l; i++){
        const shape = shapes[i];
        data.shapes.push(shape.uuid);
    }
    else data.shapes.push(shapes.uuid);
    return data;
}
class $d5b85d29c0b78636$export$1b417fc3b307a251 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(radius = 1, widthSegments = 32, heightSegments = 16, phiStart = 0, phiLength = Math.PI * 2, thetaStart = 0, thetaLength = Math.PI){
        super();
        this.type = 'SphereGeometry';
        this.parameters = {
            radius: radius,
            widthSegments: widthSegments,
            heightSegments: heightSegments,
            phiStart: phiStart,
            phiLength: phiLength,
            thetaStart: thetaStart,
            thetaLength: thetaLength
        };
        widthSegments = Math.max(3, Math.floor(widthSegments));
        heightSegments = Math.max(2, Math.floor(heightSegments));
        const thetaEnd = Math.min(thetaStart + thetaLength, Math.PI);
        let index = 0;
        const grid = [];
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // generate vertices, normals and uvs
        for(let iy = 0; iy <= heightSegments; iy++){
            const verticesRow = [];
            const v = iy / heightSegments;
            // special case for the poles
            let uOffset = 0;
            if (iy === 0 && thetaStart === 0) uOffset = 0.5 / widthSegments;
            else if (iy === heightSegments && thetaEnd === Math.PI) uOffset = -0.5 / widthSegments;
            for(let ix = 0; ix <= widthSegments; ix++){
                const u = ix / widthSegments;
                // vertex
                vertex.x = -radius * Math.cos(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
                vertex.y = radius * Math.cos(thetaStart + v * thetaLength);
                vertex.z = radius * Math.sin(phiStart + u * phiLength) * Math.sin(thetaStart + v * thetaLength);
                vertices.push(vertex.x, vertex.y, vertex.z);
                // normal
                normal.copy(vertex).normalize();
                normals.push(normal.x, normal.y, normal.z);
                // uv
                uvs.push(u + uOffset, 1 - v);
                verticesRow.push(index++);
            }
            grid.push(verticesRow);
        }
        // indices
        for(let iy = 0; iy < heightSegments; iy++)for(let ix = 0; ix < widthSegments; ix++){
            const a = grid[iy][ix + 1];
            const b = grid[iy][ix];
            const c = grid[iy + 1][ix];
            const d = grid[iy + 1][ix + 1];
            if (iy !== 0 || thetaStart > 0) indices.push(a, b, d);
            if (iy !== heightSegments - 1 || thetaEnd < Math.PI) indices.push(b, c, d);
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$1b417fc3b307a251(data.radius, data.widthSegments, data.heightSegments, data.phiStart, data.phiLength, data.thetaStart, data.thetaLength);
    }
}
class $d5b85d29c0b78636$export$fb3f7adc68bd6e02 extends $d5b85d29c0b78636$export$60e57a7d3f20ff65 {
    constructor(radius = 1, detail = 0){
        const vertices = [
            1,
            1,
            1,
            -1,
            -1,
            1,
            -1,
            1,
            -1,
            1,
            -1,
            -1
        ];
        const indices = [
            2,
            1,
            0,
            0,
            3,
            2,
            1,
            3,
            0,
            2,
            3,
            1
        ];
        super(vertices, indices, radius, detail);
        this.type = 'TetrahedronGeometry';
        this.parameters = {
            radius: radius,
            detail: detail
        };
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$fb3f7adc68bd6e02(data.radius, data.detail);
    }
}
class $d5b85d29c0b78636$export$a2312a2a1fa56495 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(radius = 1, tube = 0.4, radialSegments = 12, tubularSegments = 48, arc = Math.PI * 2){
        super();
        this.type = 'TorusGeometry';
        this.parameters = {
            radius: radius,
            tube: tube,
            radialSegments: radialSegments,
            tubularSegments: tubularSegments,
            arc: arc
        };
        radialSegments = Math.floor(radialSegments);
        tubularSegments = Math.floor(tubularSegments);
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // helper variables
        const center = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        // generate vertices, normals and uvs
        for(let j = 0; j <= radialSegments; j++)for(let i = 0; i <= tubularSegments; i++){
            const u = i / tubularSegments * arc;
            const v = j / radialSegments * Math.PI * 2;
            // vertex
            vertex.x = (radius + tube * Math.cos(v)) * Math.cos(u);
            vertex.y = (radius + tube * Math.cos(v)) * Math.sin(u);
            vertex.z = tube * Math.sin(v);
            vertices.push(vertex.x, vertex.y, vertex.z);
            // normal
            center.x = radius * Math.cos(u);
            center.y = radius * Math.sin(u);
            normal.subVectors(vertex, center).normalize();
            normals.push(normal.x, normal.y, normal.z);
            // uv
            uvs.push(i / tubularSegments);
            uvs.push(j / radialSegments);
        }
        // generate indices
        for(let j = 1; j <= radialSegments; j++)for(let i = 1; i <= tubularSegments; i++){
            // indices
            const a = (tubularSegments + 1) * j + i - 1;
            const b = (tubularSegments + 1) * (j - 1) + i - 1;
            const c = (tubularSegments + 1) * (j - 1) + i;
            const d = (tubularSegments + 1) * j + i;
            // faces
            indices.push(a, b, d);
            indices.push(b, c, d);
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$a2312a2a1fa56495(data.radius, data.tube, data.radialSegments, data.tubularSegments, data.arc);
    }
}
class $d5b85d29c0b78636$export$77e9bfadfb9ab8c8 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(radius = 1, tube = 0.4, tubularSegments = 64, radialSegments = 8, p = 2, q = 3){
        super();
        this.type = 'TorusKnotGeometry';
        this.parameters = {
            radius: radius,
            tube: tube,
            tubularSegments: tubularSegments,
            radialSegments: radialSegments,
            p: p,
            q: q
        };
        tubularSegments = Math.floor(tubularSegments);
        radialSegments = Math.floor(radialSegments);
        // buffers
        const indices = [];
        const vertices = [];
        const normals = [];
        const uvs = [];
        // helper variables
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const P1 = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const P2 = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const B = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const T = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const N = new $d5b85d29c0b78636$export$64b5c384219d3699();
        // generate vertices, normals and uvs
        for(let i = 0; i <= tubularSegments; ++i){
            // the radian "u" is used to calculate the position on the torus curve of the current tubular segment
            const u = i / tubularSegments * p * Math.PI * 2;
            // now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
            // these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions
            calculatePositionOnCurve(u, p, q, radius, P1);
            calculatePositionOnCurve(u + 0.01, p, q, radius, P2);
            // calculate orthonormal basis
            T.subVectors(P2, P1);
            N.addVectors(P2, P1);
            B.crossVectors(T, N);
            N.crossVectors(B, T);
            // normalize B, N. T can be ignored, we don't use it
            B.normalize();
            N.normalize();
            for(let j = 0; j <= radialSegments; ++j){
                // now calculate the vertices. they are nothing more than an extrusion of the torus curve.
                // because we extrude a shape in the xy-plane, there is no need to calculate a z-value.
                const v = j / radialSegments * Math.PI * 2;
                const cx = -tube * Math.cos(v);
                const cy = tube * Math.sin(v);
                // now calculate the final vertex position.
                // first we orient the extrusion with our basis vectors, then we add it to the current position on the curve
                vertex.x = P1.x + (cx * N.x + cy * B.x);
                vertex.y = P1.y + (cx * N.y + cy * B.y);
                vertex.z = P1.z + (cx * N.z + cy * B.z);
                vertices.push(vertex.x, vertex.y, vertex.z);
                // normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)
                normal.subVectors(vertex, P1).normalize();
                normals.push(normal.x, normal.y, normal.z);
                // uv
                uvs.push(i / tubularSegments);
                uvs.push(j / radialSegments);
            }
        }
        // generate indices
        for(let j = 1; j <= tubularSegments; j++)for(let i = 1; i <= radialSegments; i++){
            // indices
            const a = (radialSegments + 1) * (j - 1) + (i - 1);
            const b = (radialSegments + 1) * j + (i - 1);
            const c = (radialSegments + 1) * j + i;
            const d = (radialSegments + 1) * (j - 1) + i;
            // faces
            indices.push(a, b, d);
            indices.push(b, c, d);
        }
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
        // this function calculates the current position on the torus curve
        function calculatePositionOnCurve(u, p, q, radius, position) {
            const cu = Math.cos(u);
            const su = Math.sin(u);
            const quOverP = q / p * u;
            const cs = Math.cos(quOverP);
            position.x = radius * (2 + cs) * 0.5 * cu;
            position.y = radius * (2 + cs) * su * 0.5;
            position.z = radius * Math.sin(quOverP) * 0.5;
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    static fromJSON(data) {
        return new $d5b85d29c0b78636$export$77e9bfadfb9ab8c8(data.radius, data.tube, data.tubularSegments, data.radialSegments, data.p, data.q);
    }
}
class $d5b85d29c0b78636$export$7897d9d48904490c extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(path = new $d5b85d29c0b78636$export$bf3f4c7e459f90fc(new $d5b85d29c0b78636$export$64b5c384219d3699(-1, -1, 0), new $d5b85d29c0b78636$export$64b5c384219d3699(-1, 1, 0), new $d5b85d29c0b78636$export$64b5c384219d3699(1, 1, 0)), tubularSegments = 64, radius = 1, radialSegments = 8, closed = false){
        super();
        this.type = 'TubeGeometry';
        this.parameters = {
            path: path,
            tubularSegments: tubularSegments,
            radius: radius,
            radialSegments: radialSegments,
            closed: closed
        };
        const frames = path.computeFrenetFrames(tubularSegments, closed);
        // expose internals
        this.tangents = frames.tangents;
        this.normals = frames.normals;
        this.binormals = frames.binormals;
        // helper variables
        const vertex = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const normal = new $d5b85d29c0b78636$export$64b5c384219d3699();
        const uv = new $d5b85d29c0b78636$export$c977b3e384af9ae1();
        let P = new $d5b85d29c0b78636$export$64b5c384219d3699();
        // buffer
        const vertices = [];
        const normals = [];
        const uvs = [];
        const indices = [];
        // create buffer data
        generateBufferData();
        // build geometry
        this.setIndex(indices);
        this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        this.setAttribute('normal', new $d5b85d29c0b78636$export$cbe7a62641830ebd(normals, 3));
        this.setAttribute('uv', new $d5b85d29c0b78636$export$cbe7a62641830ebd(uvs, 2));
        // functions
        function generateBufferData() {
            for(let i = 0; i < tubularSegments; i++)generateSegment(i);
            // if the geometry is not closed, generate the last row of vertices and normals
            // at the regular position on the given path
            //
            // if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)
            generateSegment(closed === false ? tubularSegments : 0);
            // uvs are generated in a separate function.
            // this makes it easy compute correct values for closed geometries
            generateUVs();
            // finally create faces
            generateIndices();
        }
        function generateSegment(i) {
            // we use getPointAt to sample evenly distributed points from the given path
            P = path.getPointAt(i / tubularSegments, P);
            // retrieve corresponding normal and binormal
            const N = frames.normals[i];
            const B = frames.binormals[i];
            // generate normals and vertices for the current segment
            for(let j = 0; j <= radialSegments; j++){
                const v = j / radialSegments * Math.PI * 2;
                const sin = Math.sin(v);
                const cos = -Math.cos(v);
                // normal
                normal.x = cos * N.x + sin * B.x;
                normal.y = cos * N.y + sin * B.y;
                normal.z = cos * N.z + sin * B.z;
                normal.normalize();
                normals.push(normal.x, normal.y, normal.z);
                // vertex
                vertex.x = P.x + radius * normal.x;
                vertex.y = P.y + radius * normal.y;
                vertex.z = P.z + radius * normal.z;
                vertices.push(vertex.x, vertex.y, vertex.z);
            }
        }
        function generateIndices() {
            for(let j = 1; j <= tubularSegments; j++)for(let i = 1; i <= radialSegments; i++){
                const a = (radialSegments + 1) * (j - 1) + (i - 1);
                const b = (radialSegments + 1) * j + (i - 1);
                const c = (radialSegments + 1) * j + i;
                const d = (radialSegments + 1) * (j - 1) + i;
                // faces
                indices.push(a, b, d);
                indices.push(b, c, d);
            }
        }
        function generateUVs() {
            for(let i = 0; i <= tubularSegments; i++)for(let j = 0; j <= radialSegments; j++){
                uv.x = i / tubularSegments;
                uv.y = j / radialSegments;
                uvs.push(uv.x, uv.y);
            }
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.path = this.parameters.path.toJSON();
        return data;
    }
    static fromJSON(data) {
        // This only works for built-in curves (e.g. CatmullRomCurve3).
        // User defined curves or instances of CurvePath will not be deserialized.
        return new $d5b85d29c0b78636$export$7897d9d48904490c(new $d5b85d29c0b78636$var$Curves[data.path.type]().fromJSON(data.path), data.tubularSegments, data.radius, data.radialSegments, data.closed);
    }
}
class $d5b85d29c0b78636$export$4b739da06d24892b extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(geometry = null){
        super();
        this.type = 'WireframeGeometry';
        this.parameters = {
            geometry: geometry
        };
        if (geometry !== null) {
            // buffer
            const vertices = [];
            const edges = new Set();
            // helper variables
            const start = new $d5b85d29c0b78636$export$64b5c384219d3699();
            const end = new $d5b85d29c0b78636$export$64b5c384219d3699();
            if (geometry.index !== null) {
                // indexed BufferGeometry
                const position = geometry.attributes.position;
                const indices = geometry.index;
                let groups = geometry.groups;
                if (groups.length === 0) groups = [
                    {
                        start: 0,
                        count: indices.count,
                        materialIndex: 0
                    }
                ];
                // create a data structure that contains all edges without duplicates
                for(let o = 0, ol = groups.length; o < ol; ++o){
                    const group = groups[o];
                    const groupStart = group.start;
                    const groupCount = group.count;
                    for(let i = groupStart, l = groupStart + groupCount; i < l; i += 3)for(let j = 0; j < 3; j++){
                        const index1 = indices.getX(i + j);
                        const index2 = indices.getX(i + (j + 1) % 3);
                        start.fromBufferAttribute(position, index1);
                        end.fromBufferAttribute(position, index2);
                        if ($d5b85d29c0b78636$var$isUniqueEdge(start, end, edges) === true) {
                            vertices.push(start.x, start.y, start.z);
                            vertices.push(end.x, end.y, end.z);
                        }
                    }
                }
            } else {
                // non-indexed BufferGeometry
                const position = geometry.attributes.position;
                for(let i = 0, l = position.count / 3; i < l; i++)for(let j = 0; j < 3; j++){
                    // three edges per triangle, an edge is represented as (index1, index2)
                    // e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)
                    const index1 = 3 * i + j;
                    const index2 = 3 * i + (j + 1) % 3;
                    start.fromBufferAttribute(position, index1);
                    end.fromBufferAttribute(position, index2);
                    if ($d5b85d29c0b78636$var$isUniqueEdge(start, end, edges) === true) {
                        vertices.push(start.x, start.y, start.z);
                        vertices.push(end.x, end.y, end.z);
                    }
                }
            }
            // build geometry
            this.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        }
    }
    copy(source) {
        super.copy(source);
        this.parameters = Object.assign({}, source.parameters);
        return this;
    }
}
function $d5b85d29c0b78636$var$isUniqueEdge(start, end, edges) {
    const hash1 = `${start.x},${start.y},${start.z}-${end.x},${end.y},${end.z}`;
    const hash2 = `${end.x},${end.y},${end.z}-${start.x},${start.y},${start.z}`; // coincident edge
    if (edges.has(hash1) === true || edges.has(hash2) === true) return false;
    else {
        edges.add(hash1);
        edges.add(hash2);
        return true;
    }
}
var $d5b85d29c0b78636$var$Geometries = /*#__PURE__*/ Object.freeze({
    __proto__: null,
    BoxGeometry: $d5b85d29c0b78636$export$33e43285f7406bd5,
    CapsuleGeometry: $d5b85d29c0b78636$export$41680e8551036033,
    CircleGeometry: $d5b85d29c0b78636$export$d5c0e8d607467193,
    ConeGeometry: $d5b85d29c0b78636$export$a7a48974f285c9b3,
    CylinderGeometry: $d5b85d29c0b78636$export$68f745719dbe5198,
    DodecahedronGeometry: $d5b85d29c0b78636$export$c0babfeb8708fc9c,
    EdgesGeometry: $d5b85d29c0b78636$export$4730b1542707547f,
    ExtrudeGeometry: $d5b85d29c0b78636$export$598697a1efa63ca7,
    IcosahedronGeometry: $d5b85d29c0b78636$export$9567cc828c9535da,
    LatheGeometry: $d5b85d29c0b78636$export$6d839803fcd1882c,
    OctahedronGeometry: $d5b85d29c0b78636$export$1954e2b809fe361e,
    PlaneGeometry: $d5b85d29c0b78636$export$967d831af31f69ce,
    PolyhedronGeometry: $d5b85d29c0b78636$export$60e57a7d3f20ff65,
    RingGeometry: $d5b85d29c0b78636$export$68cb731f50f614af,
    ShapeGeometry: $d5b85d29c0b78636$export$57a29a1c803e9065,
    SphereGeometry: $d5b85d29c0b78636$export$1b417fc3b307a251,
    TetrahedronGeometry: $d5b85d29c0b78636$export$fb3f7adc68bd6e02,
    TorusGeometry: $d5b85d29c0b78636$export$a2312a2a1fa56495,
    TorusKnotGeometry: $d5b85d29c0b78636$export$77e9bfadfb9ab8c8,
    TubeGeometry: $d5b85d29c0b78636$export$7897d9d48904490c,
    WireframeGeometry: $d5b85d29c0b78636$export$4b739da06d24892b
});
class $d5b85d29c0b78636$export$e8564da406055a3 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isShadowMaterial = true;
        this.type = 'ShadowMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0x000000);
        this.transparent = true;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.fog = source.fog;
        return this;
    }
}
class $d5b85d29c0b78636$export$21c421a2e1df9d22 extends $d5b85d29c0b78636$export$83c7d75d550a8b0d {
    constructor(parameters){
        super(parameters);
        this.isRawShaderMaterial = true;
        this.type = 'RawShaderMaterial';
    }
}
class $d5b85d29c0b78636$export$f2980790215acccd extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshStandardMaterial = true;
        this.type = 'MeshStandardMaterial';
        this.defines = {
            'STANDARD': ''
        };
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff); // diffuse
        this.roughness = 1.0;
        this.metalness = 0.0;
        this.map = null;
        this.lightMap = null;
        this.lightMapIntensity = 1.0;
        this.aoMap = null;
        this.aoMapIntensity = 1.0;
        this.emissive = new $d5b85d29c0b78636$export$892596cec99bc70e(0x000000);
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;
        this.bumpMap = null;
        this.bumpScale = 1;
        this.normalMap = null;
        this.normalMapType = $d5b85d29c0b78636$export$2852a58ebdac27b8;
        this.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.roughnessMap = null;
        this.metalnessMap = null;
        this.alphaMap = null;
        this.envMap = null;
        this.envMapRotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        this.envMapIntensity = 1.0;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';
        this.flatShading = false;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.defines = {
            'STANDARD': ''
        };
        this.color.copy(source.color);
        this.roughness = source.roughness;
        this.metalness = source.metalness;
        this.map = source.map;
        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;
        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;
        this.emissive.copy(source.emissive);
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;
        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;
        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy(source.normalScale);
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.roughnessMap = source.roughnessMap;
        this.metalnessMap = source.metalnessMap;
        this.alphaMap = source.alphaMap;
        this.envMap = source.envMap;
        this.envMapRotation.copy(source.envMapRotation);
        this.envMapIntensity = source.envMapIntensity;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;
        this.flatShading = source.flatShading;
        this.fog = source.fog;
        return this;
    }
}
class $d5b85d29c0b78636$export$28d04986c4269c9f extends $d5b85d29c0b78636$export$f2980790215acccd {
    constructor(parameters){
        super();
        this.isMeshPhysicalMaterial = true;
        this.defines = {
            'STANDARD': '',
            'PHYSICAL': ''
        };
        this.type = 'MeshPhysicalMaterial';
        this.anisotropyRotation = 0;
        this.anisotropyMap = null;
        this.clearcoatMap = null;
        this.clearcoatRoughness = 0.0;
        this.clearcoatRoughnessMap = null;
        this.clearcoatNormalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.clearcoatNormalMap = null;
        this.ior = 1.5;
        Object.defineProperty(this, 'reflectivity', {
            get: function() {
                return $d5b85d29c0b78636$var$clamp(2.5 * (this.ior - 1) / (this.ior + 1), 0, 1);
            },
            set: function(reflectivity) {
                this.ior = (1 + 0.4 * reflectivity) / (1 - 0.4 * reflectivity);
            }
        });
        this.iridescenceMap = null;
        this.iridescenceIOR = 1.3;
        this.iridescenceThicknessRange = [
            100,
            400
        ];
        this.iridescenceThicknessMap = null;
        this.sheenColor = new $d5b85d29c0b78636$export$892596cec99bc70e(0x000000);
        this.sheenColorMap = null;
        this.sheenRoughness = 1.0;
        this.sheenRoughnessMap = null;
        this.transmissionMap = null;
        this.thickness = 0;
        this.thicknessMap = null;
        this.attenuationDistance = Infinity;
        this.attenuationColor = new $d5b85d29c0b78636$export$892596cec99bc70e(1, 1, 1);
        this.specularIntensity = 1.0;
        this.specularIntensityMap = null;
        this.specularColor = new $d5b85d29c0b78636$export$892596cec99bc70e(1, 1, 1);
        this.specularColorMap = null;
        this._anisotropy = 0;
        this._clearcoat = 0;
        this._dispersion = 0;
        this._iridescence = 0;
        this._sheen = 0.0;
        this._transmission = 0;
        this.setValues(parameters);
    }
    get anisotropy() {
        return this._anisotropy;
    }
    set anisotropy(value) {
        if (this._anisotropy > 0 !== value > 0) this.version++;
        this._anisotropy = value;
    }
    get clearcoat() {
        return this._clearcoat;
    }
    set clearcoat(value) {
        if (this._clearcoat > 0 !== value > 0) this.version++;
        this._clearcoat = value;
    }
    get iridescence() {
        return this._iridescence;
    }
    set iridescence(value) {
        if (this._iridescence > 0 !== value > 0) this.version++;
        this._iridescence = value;
    }
    get dispersion() {
        return this._dispersion;
    }
    set dispersion(value) {
        if (this._dispersion > 0 !== value > 0) this.version++;
        this._dispersion = value;
    }
    get sheen() {
        return this._sheen;
    }
    set sheen(value) {
        if (this._sheen > 0 !== value > 0) this.version++;
        this._sheen = value;
    }
    get transmission() {
        return this._transmission;
    }
    set transmission(value) {
        if (this._transmission > 0 !== value > 0) this.version++;
        this._transmission = value;
    }
    copy(source) {
        super.copy(source);
        this.defines = {
            'STANDARD': '',
            'PHYSICAL': ''
        };
        this.anisotropy = source.anisotropy;
        this.anisotropyRotation = source.anisotropyRotation;
        this.anisotropyMap = source.anisotropyMap;
        this.clearcoat = source.clearcoat;
        this.clearcoatMap = source.clearcoatMap;
        this.clearcoatRoughness = source.clearcoatRoughness;
        this.clearcoatRoughnessMap = source.clearcoatRoughnessMap;
        this.clearcoatNormalMap = source.clearcoatNormalMap;
        this.clearcoatNormalScale.copy(source.clearcoatNormalScale);
        this.dispersion = source.dispersion;
        this.ior = source.ior;
        this.iridescence = source.iridescence;
        this.iridescenceMap = source.iridescenceMap;
        this.iridescenceIOR = source.iridescenceIOR;
        this.iridescenceThicknessRange = [
            ...source.iridescenceThicknessRange
        ];
        this.iridescenceThicknessMap = source.iridescenceThicknessMap;
        this.sheen = source.sheen;
        this.sheenColor.copy(source.sheenColor);
        this.sheenColorMap = source.sheenColorMap;
        this.sheenRoughness = source.sheenRoughness;
        this.sheenRoughnessMap = source.sheenRoughnessMap;
        this.transmission = source.transmission;
        this.transmissionMap = source.transmissionMap;
        this.thickness = source.thickness;
        this.thicknessMap = source.thicknessMap;
        this.attenuationDistance = source.attenuationDistance;
        this.attenuationColor.copy(source.attenuationColor);
        this.specularIntensity = source.specularIntensity;
        this.specularIntensityMap = source.specularIntensityMap;
        this.specularColor.copy(source.specularColor);
        this.specularColorMap = source.specularColorMap;
        return this;
    }
}
class $d5b85d29c0b78636$export$24c72f71cbaf0678 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshPhongMaterial = true;
        this.type = 'MeshPhongMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff); // diffuse
        this.specular = new $d5b85d29c0b78636$export$892596cec99bc70e(0x111111);
        this.shininess = 30;
        this.map = null;
        this.lightMap = null;
        this.lightMapIntensity = 1.0;
        this.aoMap = null;
        this.aoMapIntensity = 1.0;
        this.emissive = new $d5b85d29c0b78636$export$892596cec99bc70e(0x000000);
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;
        this.bumpMap = null;
        this.bumpScale = 1;
        this.normalMap = null;
        this.normalMapType = $d5b85d29c0b78636$export$2852a58ebdac27b8;
        this.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.specularMap = null;
        this.alphaMap = null;
        this.envMap = null;
        this.envMapRotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        this.combine = $d5b85d29c0b78636$export$e50ac29801f1774d;
        this.reflectivity = 1;
        this.refractionRatio = 0.98;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';
        this.flatShading = false;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.specular.copy(source.specular);
        this.shininess = source.shininess;
        this.map = source.map;
        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;
        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;
        this.emissive.copy(source.emissive);
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;
        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;
        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy(source.normalScale);
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.specularMap = source.specularMap;
        this.alphaMap = source.alphaMap;
        this.envMap = source.envMap;
        this.envMapRotation.copy(source.envMapRotation);
        this.combine = source.combine;
        this.reflectivity = source.reflectivity;
        this.refractionRatio = source.refractionRatio;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;
        this.flatShading = source.flatShading;
        this.fog = source.fog;
        return this;
    }
}
class $d5b85d29c0b78636$export$df893cf97e765622 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshToonMaterial = true;
        this.defines = {
            'TOON': ''
        };
        this.type = 'MeshToonMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff);
        this.map = null;
        this.gradientMap = null;
        this.lightMap = null;
        this.lightMapIntensity = 1.0;
        this.aoMap = null;
        this.aoMapIntensity = 1.0;
        this.emissive = new $d5b85d29c0b78636$export$892596cec99bc70e(0x000000);
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;
        this.bumpMap = null;
        this.bumpScale = 1;
        this.normalMap = null;
        this.normalMapType = $d5b85d29c0b78636$export$2852a58ebdac27b8;
        this.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.alphaMap = null;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.map = source.map;
        this.gradientMap = source.gradientMap;
        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;
        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;
        this.emissive.copy(source.emissive);
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;
        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;
        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy(source.normalScale);
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.alphaMap = source.alphaMap;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;
        this.fog = source.fog;
        return this;
    }
}
class $d5b85d29c0b78636$export$bfe8c0a091f41ae7 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshNormalMaterial = true;
        this.type = 'MeshNormalMaterial';
        this.bumpMap = null;
        this.bumpScale = 1;
        this.normalMap = null;
        this.normalMapType = $d5b85d29c0b78636$export$2852a58ebdac27b8;
        this.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.flatShading = false;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;
        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy(source.normalScale);
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.flatShading = source.flatShading;
        return this;
    }
}
class $d5b85d29c0b78636$export$5023a9a8114806b8 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshLambertMaterial = true;
        this.type = 'MeshLambertMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff); // diffuse
        this.map = null;
        this.lightMap = null;
        this.lightMapIntensity = 1.0;
        this.aoMap = null;
        this.aoMapIntensity = 1.0;
        this.emissive = new $d5b85d29c0b78636$export$892596cec99bc70e(0x000000);
        this.emissiveIntensity = 1.0;
        this.emissiveMap = null;
        this.bumpMap = null;
        this.bumpScale = 1;
        this.normalMap = null;
        this.normalMapType = $d5b85d29c0b78636$export$2852a58ebdac27b8;
        this.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.specularMap = null;
        this.alphaMap = null;
        this.envMap = null;
        this.envMapRotation = new $d5b85d29c0b78636$export$d93cc409a0768c5f();
        this.combine = $d5b85d29c0b78636$export$e50ac29801f1774d;
        this.reflectivity = 1;
        this.refractionRatio = 0.98;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.wireframeLinecap = 'round';
        this.wireframeLinejoin = 'round';
        this.flatShading = false;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.color.copy(source.color);
        this.map = source.map;
        this.lightMap = source.lightMap;
        this.lightMapIntensity = source.lightMapIntensity;
        this.aoMap = source.aoMap;
        this.aoMapIntensity = source.aoMapIntensity;
        this.emissive.copy(source.emissive);
        this.emissiveMap = source.emissiveMap;
        this.emissiveIntensity = source.emissiveIntensity;
        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;
        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy(source.normalScale);
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.specularMap = source.specularMap;
        this.alphaMap = source.alphaMap;
        this.envMap = source.envMap;
        this.envMapRotation.copy(source.envMapRotation);
        this.combine = source.combine;
        this.reflectivity = source.reflectivity;
        this.refractionRatio = source.refractionRatio;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        this.wireframeLinecap = source.wireframeLinecap;
        this.wireframeLinejoin = source.wireframeLinejoin;
        this.flatShading = source.flatShading;
        this.fog = source.fog;
        return this;
    }
}
class $d5b85d29c0b78636$export$2698c22ec13825db extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshDepthMaterial = true;
        this.type = 'MeshDepthMaterial';
        this.depthPacking = $d5b85d29c0b78636$export$deeb383078690b50;
        this.map = null;
        this.alphaMap = null;
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.wireframe = false;
        this.wireframeLinewidth = 1;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.depthPacking = source.depthPacking;
        this.map = source.map;
        this.alphaMap = source.alphaMap;
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.wireframe = source.wireframe;
        this.wireframeLinewidth = source.wireframeLinewidth;
        return this;
    }
}
class $d5b85d29c0b78636$export$33e187ed002f2a19 extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshDistanceMaterial = true;
        this.type = 'MeshDistanceMaterial';
        this.map = null;
        this.alphaMap = null;
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.map = source.map;
        this.alphaMap = source.alphaMap;
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        return this;
    }
}
class $d5b85d29c0b78636$export$6f5fef6235ec12ee extends $d5b85d29c0b78636$export$a2d8b23205c25948 {
    constructor(parameters){
        super();
        this.isMeshMatcapMaterial = true;
        this.defines = {
            'MATCAP': ''
        };
        this.type = 'MeshMatcapMaterial';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff); // diffuse
        this.matcap = null;
        this.map = null;
        this.bumpMap = null;
        this.bumpScale = 1;
        this.normalMap = null;
        this.normalMapType = $d5b85d29c0b78636$export$2852a58ebdac27b8;
        this.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this.displacementMap = null;
        this.displacementScale = 1;
        this.displacementBias = 0;
        this.alphaMap = null;
        this.flatShading = false;
        this.fog = true;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.defines = {
            'MATCAP': ''
        };
        this.color.copy(source.color);
        this.matcap = source.matcap;
        this.map = source.map;
        this.bumpMap = source.bumpMap;
        this.bumpScale = source.bumpScale;
        this.normalMap = source.normalMap;
        this.normalMapType = source.normalMapType;
        this.normalScale.copy(source.normalScale);
        this.displacementMap = source.displacementMap;
        this.displacementScale = source.displacementScale;
        this.displacementBias = source.displacementBias;
        this.alphaMap = source.alphaMap;
        this.flatShading = source.flatShading;
        this.fog = source.fog;
        return this;
    }
}
class $d5b85d29c0b78636$export$327886a3efaeaebe extends $d5b85d29c0b78636$export$fbaaa33907730a0c {
    constructor(parameters){
        super();
        this.isLineDashedMaterial = true;
        this.type = 'LineDashedMaterial';
        this.scale = 1;
        this.dashSize = 3;
        this.gapSize = 1;
        this.setValues(parameters);
    }
    copy(source) {
        super.copy(source);
        this.scale = source.scale;
        this.dashSize = source.dashSize;
        this.gapSize = source.gapSize;
        return this;
    }
}
// converts an array to a specific type
function $d5b85d29c0b78636$var$convertArray(array, type, forceClone) {
    if (!array || // let 'undefined' and 'null' pass
    !forceClone && array.constructor === type) return array;
    if (typeof type.BYTES_PER_ELEMENT === 'number') return new type(array); // create typed array
    return Array.prototype.slice.call(array); // create Array
}
function $d5b85d29c0b78636$var$isTypedArray(object) {
    return ArrayBuffer.isView(object) && !(object instanceof DataView);
}
// returns an array by which times and values can be sorted
function $d5b85d29c0b78636$var$getKeyframeOrder(times) {
    function compareTime(i, j) {
        return times[i] - times[j];
    }
    const n = times.length;
    const result = new Array(n);
    for(let i = 0; i !== n; ++i)result[i] = i;
    result.sort(compareTime);
    return result;
}
// uses the array previously returned by 'getKeyframeOrder' to sort data
function $d5b85d29c0b78636$var$sortedArray(values, stride, order) {
    const nValues = values.length;
    const result = new values.constructor(nValues);
    for(let i = 0, dstOffset = 0; dstOffset !== nValues; ++i){
        const srcOffset = order[i] * stride;
        for(let j = 0; j !== stride; ++j)result[dstOffset++] = values[srcOffset + j];
    }
    return result;
}
// function for parsing AOS keyframe formats
function $d5b85d29c0b78636$var$flattenJSON(jsonKeys, times, values, valuePropertyName) {
    let i = 1, key = jsonKeys[0];
    while(key !== undefined && key[valuePropertyName] === undefined)key = jsonKeys[i++];
    if (key === undefined) return; // no data
    let value = key[valuePropertyName];
    if (value === undefined) return; // no data
    if (Array.isArray(value)) do {
        value = key[valuePropertyName];
        if (value !== undefined) {
            times.push(key.time);
            values.push.apply(values, value); // push all elements
        }
        key = jsonKeys[i++];
    }while (key !== undefined);
    else if (value.toArray !== undefined) // ...assume THREE.Math-ish
    do {
        value = key[valuePropertyName];
        if (value !== undefined) {
            times.push(key.time);
            value.toArray(values, values.length);
        }
        key = jsonKeys[i++];
    }while (key !== undefined);
    else // otherwise push as-is
    do {
        value = key[valuePropertyName];
        if (value !== undefined) {
            times.push(key.time);
            values.push(value);
        }
        key = jsonKeys[i++];
    }while (key !== undefined);
}
function $d5b85d29c0b78636$var$subclip(sourceClip, name, startFrame, endFrame, fps = 30) {
    const clip = sourceClip.clone();
    clip.name = name;
    const tracks = [];
    for(let i = 0; i < clip.tracks.length; ++i){
        const track = clip.tracks[i];
        const valueSize = track.getValueSize();
        const times = [];
        const values = [];
        for(let j = 0; j < track.times.length; ++j){
            const frame = track.times[j] * fps;
            if (frame < startFrame || frame >= endFrame) continue;
            times.push(track.times[j]);
            for(let k = 0; k < valueSize; ++k)values.push(track.values[j * valueSize + k]);
        }
        if (times.length === 0) continue;
        track.times = $d5b85d29c0b78636$var$convertArray(times, track.times.constructor);
        track.values = $d5b85d29c0b78636$var$convertArray(values, track.values.constructor);
        tracks.push(track);
    }
    clip.tracks = tracks;
    // find minimum .times value across all tracks in the trimmed clip
    let minStartTime = Infinity;
    for(let i = 0; i < clip.tracks.length; ++i)if (minStartTime > clip.tracks[i].times[0]) minStartTime = clip.tracks[i].times[0];
    // shift all tracks such that clip begins at t=0
    for(let i = 0; i < clip.tracks.length; ++i)clip.tracks[i].shift(-1 * minStartTime);
    clip.resetDuration();
    return clip;
}
function $d5b85d29c0b78636$var$makeClipAdditive(targetClip, referenceFrame = 0, referenceClip = targetClip, fps = 30) {
    if (fps <= 0) fps = 30;
    const numTracks = referenceClip.tracks.length;
    const referenceTime = referenceFrame / fps;
    // Make each track's values relative to the values at the reference frame
    for(let i = 0; i < numTracks; ++i){
        const referenceTrack = referenceClip.tracks[i];
        const referenceTrackType = referenceTrack.ValueTypeName;
        // Skip this track if it's non-numeric
        if (referenceTrackType === 'bool' || referenceTrackType === 'string') continue;
        // Find the track in the target clip whose name and type matches the reference track
        const targetTrack = targetClip.tracks.find(function(track) {
            return track.name === referenceTrack.name && track.ValueTypeName === referenceTrackType;
        });
        if (targetTrack === undefined) continue;
        let referenceOffset = 0;
        const referenceValueSize = referenceTrack.getValueSize();
        if (referenceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) referenceOffset = referenceValueSize / 3;
        let targetOffset = 0;
        const targetValueSize = targetTrack.getValueSize();
        if (targetTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) targetOffset = targetValueSize / 3;
        const lastIndex = referenceTrack.times.length - 1;
        let referenceValue;
        // Find the value to subtract out of the track
        if (referenceTime <= referenceTrack.times[0]) {
            // Reference frame is earlier than the first keyframe, so just use the first keyframe
            const startIndex = referenceOffset;
            const endIndex = referenceValueSize - referenceOffset;
            referenceValue = referenceTrack.values.slice(startIndex, endIndex);
        } else if (referenceTime >= referenceTrack.times[lastIndex]) {
            // Reference frame is after the last keyframe, so just use the last keyframe
            const startIndex = lastIndex * referenceValueSize + referenceOffset;
            const endIndex = startIndex + referenceValueSize - referenceOffset;
            referenceValue = referenceTrack.values.slice(startIndex, endIndex);
        } else {
            // Interpolate to the reference value
            const interpolant = referenceTrack.createInterpolant();
            const startIndex = referenceOffset;
            const endIndex = referenceValueSize - referenceOffset;
            interpolant.evaluate(referenceTime);
            referenceValue = interpolant.resultBuffer.slice(startIndex, endIndex);
        }
        // Conjugate the quaternion
        if (referenceTrackType === 'quaternion') {
            const referenceQuat = new $d5b85d29c0b78636$export$23d6a54f0bbc85a3().fromArray(referenceValue).normalize().conjugate();
            referenceQuat.toArray(referenceValue);
        }
        // Subtract the reference value from all of the track values
        const numTimes = targetTrack.times.length;
        for(let j = 0; j < numTimes; ++j){
            const valueStart = j * targetValueSize + targetOffset;
            if (referenceTrackType === 'quaternion') // Multiply the conjugate for quaternion track types
            $d5b85d29c0b78636$export$23d6a54f0bbc85a3.multiplyQuaternionsFlat(targetTrack.values, valueStart, referenceValue, 0, targetTrack.values, valueStart);
            else {
                const valueEnd = targetValueSize - targetOffset * 2;
                // Subtract each value for all other numeric track types
                for(let k = 0; k < valueEnd; ++k)targetTrack.values[valueStart + k] -= referenceValue[k];
            }
        }
    }
    targetClip.blendMode = $d5b85d29c0b78636$export$d875e029ef558d3;
    return targetClip;
}
const $d5b85d29c0b78636$export$7ee8caa573e71ad1 = {
    convertArray: $d5b85d29c0b78636$var$convertArray,
    isTypedArray: $d5b85d29c0b78636$var$isTypedArray,
    getKeyframeOrder: $d5b85d29c0b78636$var$getKeyframeOrder,
    sortedArray: $d5b85d29c0b78636$var$sortedArray,
    flattenJSON: $d5b85d29c0b78636$var$flattenJSON,
    subclip: $d5b85d29c0b78636$var$subclip,
    makeClipAdditive: $d5b85d29c0b78636$var$makeClipAdditive
};
/**
 * Abstract base class of interpolants over parametric samples.
 *
 * The parameter domain is one dimensional, typically the time or a path
 * along a curve defined by the data.
 *
 * The sample values can have any dimensionality and derived classes may
 * apply special interpretations to the data.
 *
 * This class provides the interval seek in a Template Method, deferring
 * the actual interpolation to derived classes.
 *
 * Time complexity is O(1) for linear access crossing at most two points
 * and O(log N) for random access, where N is the number of positions.
 *
 * References:
 *
 * 		http://www.oodesign.com/template-method-pattern.html
 *
 */ class $d5b85d29c0b78636$export$b558baee9c0f72d3 {
    constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
        this.parameterPositions = parameterPositions;
        this._cachedIndex = 0;
        this.resultBuffer = resultBuffer !== undefined ? resultBuffer : new sampleValues.constructor(sampleSize);
        this.sampleValues = sampleValues;
        this.valueSize = sampleSize;
        this.settings = null;
        this.DefaultSettings_ = {};
    }
    evaluate(t) {
        const pp = this.parameterPositions;
        let i1 = this._cachedIndex, t1 = pp[i1], t0 = pp[i1 - 1];
        validate_interval: {
            seek: {
                let right;
                linear_scan: {
                    //- See http://jsperf.com/comparison-to-undefined/3
                    //- slower code:
                    //-
                    //- 				if ( t >= t1 || t1 === undefined ) {
                    forward_scan: if (!(t < t1)) {
                        for(let giveUpAt = i1 + 2;;){
                            if (t1 === undefined) {
                                if (t < t0) break forward_scan;
                                // after end
                                i1 = pp.length;
                                this._cachedIndex = i1;
                                return this.copySampleValue_(i1 - 1);
                            }
                            if (i1 === giveUpAt) break; // this loop
                            t0 = t1;
                            t1 = pp[++i1];
                            if (t < t1) break seek;
                        }
                        // prepare binary search on the right side of the index
                        right = pp.length;
                        break linear_scan;
                    }
                    //- slower code:
                    //-					if ( t < t0 || t0 === undefined ) {
                    if (!(t >= t0)) {
                        // looping?
                        const t1global = pp[1];
                        if (t < t1global) {
                            i1 = 2; // + 1, using the scan for the details
                            t0 = t1global;
                        }
                        // linear reverse scan
                        for(let giveUpAt = i1 - 2;;){
                            if (t0 === undefined) {
                                // before start
                                this._cachedIndex = 0;
                                return this.copySampleValue_(0);
                            }
                            if (i1 === giveUpAt) break; // this loop
                            t1 = t0;
                            t0 = pp[--i1 - 1];
                            if (t >= t0) break seek;
                        }
                        // prepare binary search on the left side of the index
                        right = i1;
                        i1 = 0;
                        break linear_scan;
                    }
                    break validate_interval;
                } // linear scan
                // binary search
                while(i1 < right){
                    const mid = i1 + right >>> 1;
                    if (t < pp[mid]) right = mid;
                    else i1 = mid + 1;
                }
                t1 = pp[i1];
                t0 = pp[i1 - 1];
                // check boundary cases, again
                if (t0 === undefined) {
                    this._cachedIndex = 0;
                    return this.copySampleValue_(0);
                }
                if (t1 === undefined) {
                    i1 = pp.length;
                    this._cachedIndex = i1;
                    return this.copySampleValue_(i1 - 1);
                }
            } // seek
            this._cachedIndex = i1;
            this.intervalChanged_(i1, t0, t1);
        } // validate_interval
        return this.interpolate_(i1, t0, t, t1);
    }
    getSettings_() {
        return this.settings || this.DefaultSettings_;
    }
    copySampleValue_(index) {
        // copies a sample value to the result buffer
        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset = index * stride;
        for(let i = 0; i !== stride; ++i)result[i] = values[offset + i];
        return result;
    }
    // Template methods for derived classes:
    interpolate_() {
        throw new Error('call to abstract method');
    // implementations shall return this.resultBuffer
    }
    intervalChanged_() {
    // empty
    }
}
/**
 * Fast and simple cubic spline interpolant.
 *
 * It was derived from a Hermitian construction setting the first derivative
 * at each sample position to the linear slope between neighboring positions
 * over their parameter interval.
 */ class $d5b85d29c0b78636$export$3646682e7a3959 extends $d5b85d29c0b78636$export$b558baee9c0f72d3 {
    constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
        this._weightPrev = -0;
        this._offsetPrev = -0;
        this._weightNext = -0;
        this._offsetNext = -0;
        this.DefaultSettings_ = {
            endingStart: $d5b85d29c0b78636$export$7f795934b84ab523,
            endingEnd: $d5b85d29c0b78636$export$7f795934b84ab523
        };
    }
    intervalChanged_(i1, t0, t1) {
        const pp = this.parameterPositions;
        let iPrev = i1 - 2, iNext = i1 + 1, tPrev = pp[iPrev], tNext = pp[iNext];
        if (tPrev === undefined) switch(this.getSettings_().endingStart){
            case $d5b85d29c0b78636$export$24a4ccb5099273b5:
                // f'(t0) = 0
                iPrev = i1;
                tPrev = 2 * t0 - t1;
                break;
            case $d5b85d29c0b78636$export$8e8c3ecdcd8e1fee:
                // use the other end of the curve
                iPrev = pp.length - 2;
                tPrev = t0 + pp[iPrev] - pp[iPrev + 1];
                break;
            default:
                // f''(t0) = 0 a.k.a. Natural Spline
                iPrev = i1;
                tPrev = t1;
        }
        if (tNext === undefined) switch(this.getSettings_().endingEnd){
            case $d5b85d29c0b78636$export$24a4ccb5099273b5:
                // f'(tN) = 0
                iNext = i1;
                tNext = 2 * t1 - t0;
                break;
            case $d5b85d29c0b78636$export$8e8c3ecdcd8e1fee:
                // use the other end of the curve
                iNext = 1;
                tNext = t1 + pp[1] - pp[0];
                break;
            default:
                // f''(tN) = 0, a.k.a. Natural Spline
                iNext = i1 - 1;
                tNext = t0;
        }
        const halfDt = (t1 - t0) * 0.5, stride = this.valueSize;
        this._weightPrev = halfDt / (t0 - tPrev);
        this._weightNext = halfDt / (tNext - t1);
        this._offsetPrev = iPrev * stride;
        this._offsetNext = iNext * stride;
    }
    interpolate_(i1, t0, t, t1) {
        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, o1 = i1 * stride, o0 = o1 - stride, oP = this._offsetPrev, oN = this._offsetNext, wP = this._weightPrev, wN = this._weightNext, p = (t - t0) / (t1 - t0), pp = p * p, ppp = pp * p;
        // evaluate polynomials
        const sP = -wP * ppp + 2 * wP * pp - wP * p;
        const s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p + 1;
        const s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p;
        const sN = wN * ppp - wN * pp;
        // combine data linearly
        for(let i = 0; i !== stride; ++i)result[i] = sP * values[oP + i] + s0 * values[o0 + i] + s1 * values[o1 + i] + sN * values[oN + i];
        return result;
    }
}
class $d5b85d29c0b78636$export$a8e6009059f51e1a extends $d5b85d29c0b78636$export$b558baee9c0f72d3 {
    constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
    }
    interpolate_(i1, t0, t, t1) {
        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset1 = i1 * stride, offset0 = offset1 - stride, weight1 = (t - t0) / (t1 - t0), weight0 = 1 - weight1;
        for(let i = 0; i !== stride; ++i)result[i] = values[offset0 + i] * weight0 + values[offset1 + i] * weight1;
        return result;
    }
}
/**
 *
 * Interpolant that evaluates to the sample value at the position preceding
 * the parameter.
 */ class $d5b85d29c0b78636$export$fb9758ef7ef8d5cc extends $d5b85d29c0b78636$export$b558baee9c0f72d3 {
    constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
    }
    interpolate_(i1 /*, t0, t, t1 */ ) {
        return this.copySampleValue_(i1 - 1);
    }
}
class $d5b85d29c0b78636$export$b0e479f45b7006d6 {
    constructor(name, times, values, interpolation){
        if (name === undefined) throw new Error('THREE.KeyframeTrack: track name is undefined');
        if (times === undefined || times.length === 0) throw new Error('THREE.KeyframeTrack: no keyframes in track named ' + name);
        this.name = name;
        this.times = $d5b85d29c0b78636$var$convertArray(times, this.TimeBufferType);
        this.values = $d5b85d29c0b78636$var$convertArray(values, this.ValueBufferType);
        this.setInterpolation(interpolation || this.DefaultInterpolation);
    }
    // Serialization (in static context, because of constructor invocation
    // and automatic invocation of .toJSON):
    static toJSON(track) {
        const trackType = track.constructor;
        let json;
        // derived classes can define a static toJSON method
        if (trackType.toJSON !== this.toJSON) json = trackType.toJSON(track);
        else {
            // by default, we assume the data can be serialized as-is
            json = {
                'name': track.name,
                'times': $d5b85d29c0b78636$var$convertArray(track.times, Array),
                'values': $d5b85d29c0b78636$var$convertArray(track.values, Array)
            };
            const interpolation = track.getInterpolation();
            if (interpolation !== track.DefaultInterpolation) json.interpolation = interpolation;
        }
        json.type = track.ValueTypeName; // mandatory
        return json;
    }
    InterpolantFactoryMethodDiscrete(result) {
        return new $d5b85d29c0b78636$export$fb9758ef7ef8d5cc(this.times, this.values, this.getValueSize(), result);
    }
    InterpolantFactoryMethodLinear(result) {
        return new $d5b85d29c0b78636$export$a8e6009059f51e1a(this.times, this.values, this.getValueSize(), result);
    }
    InterpolantFactoryMethodSmooth(result) {
        return new $d5b85d29c0b78636$export$3646682e7a3959(this.times, this.values, this.getValueSize(), result);
    }
    setInterpolation(interpolation) {
        let factoryMethod;
        switch(interpolation){
            case $d5b85d29c0b78636$export$995b32462a65e855:
                factoryMethod = this.InterpolantFactoryMethodDiscrete;
                break;
            case $d5b85d29c0b78636$export$30fac1aace31cf4d:
                factoryMethod = this.InterpolantFactoryMethodLinear;
                break;
            case $d5b85d29c0b78636$export$198b11ff4c72bb30:
                factoryMethod = this.InterpolantFactoryMethodSmooth;
                break;
        }
        if (factoryMethod === undefined) {
            const message = 'unsupported interpolation for ' + this.ValueTypeName + ' keyframe track named ' + this.name;
            if (this.createInterpolant === undefined) {
                // fall back to default, unless the default itself is messed up
                if (interpolation !== this.DefaultInterpolation) this.setInterpolation(this.DefaultInterpolation);
                else throw new Error(message); // fatal, in this case
            }
            console.warn('THREE.KeyframeTrack:', message);
            return this;
        }
        this.createInterpolant = factoryMethod;
        return this;
    }
    getInterpolation() {
        switch(this.createInterpolant){
            case this.InterpolantFactoryMethodDiscrete:
                return $d5b85d29c0b78636$export$995b32462a65e855;
            case this.InterpolantFactoryMethodLinear:
                return $d5b85d29c0b78636$export$30fac1aace31cf4d;
            case this.InterpolantFactoryMethodSmooth:
                return $d5b85d29c0b78636$export$198b11ff4c72bb30;
        }
    }
    getValueSize() {
        return this.values.length / this.times.length;
    }
    // move all keyframes either forwards or backwards in time
    shift(timeOffset) {
        if (timeOffset !== 0.0) {
            const times = this.times;
            for(let i = 0, n = times.length; i !== n; ++i)times[i] += timeOffset;
        }
        return this;
    }
    // scale all keyframe times by a factor (useful for frame <-> seconds conversions)
    scale(timeScale) {
        if (timeScale !== 1.0) {
            const times = this.times;
            for(let i = 0, n = times.length; i !== n; ++i)times[i] *= timeScale;
        }
        return this;
    }
    // removes keyframes before and after animation without changing any values within the range [startTime, endTime].
    // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
    trim(startTime, endTime) {
        const times = this.times, nKeys = times.length;
        let from = 0, to = nKeys - 1;
        while(from !== nKeys && times[from] < startTime)++from;
        while(to !== -1 && times[to] > endTime)--to;
        ++to; // inclusive -> exclusive bound
        if (from !== 0 || to !== nKeys) {
            // empty tracks are forbidden, so keep at least one keyframe
            if (from >= to) {
                to = Math.max(to, 1);
                from = to - 1;
            }
            const stride = this.getValueSize();
            this.times = times.slice(from, to);
            this.values = this.values.slice(from * stride, to * stride);
        }
        return this;
    }
    // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
    validate() {
        let valid = true;
        const valueSize = this.getValueSize();
        if (valueSize - Math.floor(valueSize) !== 0) {
            console.error('THREE.KeyframeTrack: Invalid value size in track.', this);
            valid = false;
        }
        const times = this.times, values = this.values, nKeys = times.length;
        if (nKeys === 0) {
            console.error('THREE.KeyframeTrack: Track is empty.', this);
            valid = false;
        }
        let prevTime = null;
        for(let i = 0; i !== nKeys; i++){
            const currTime = times[i];
            if (typeof currTime === 'number' && isNaN(currTime)) {
                console.error('THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime);
                valid = false;
                break;
            }
            if (prevTime !== null && prevTime > currTime) {
                console.error('THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime);
                valid = false;
                break;
            }
            prevTime = currTime;
        }
        if (values !== undefined) {
            if ($d5b85d29c0b78636$var$isTypedArray(values)) for(let i = 0, n = values.length; i !== n; ++i){
                const value = values[i];
                if (isNaN(value)) {
                    console.error('THREE.KeyframeTrack: Value is not a valid number.', this, i, value);
                    valid = false;
                    break;
                }
            }
        }
        return valid;
    }
    // removes equivalent sequential keys as common in morph target sequences
    // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
    optimize() {
        // times or values may be shared with other tracks, so overwriting is unsafe
        const times = this.times.slice(), values = this.values.slice(), stride = this.getValueSize(), smoothInterpolation = this.getInterpolation() === $d5b85d29c0b78636$export$198b11ff4c72bb30, lastIndex = times.length - 1;
        let writeIndex = 1;
        for(let i = 1; i < lastIndex; ++i){
            let keep = false;
            const time = times[i];
            const timeNext = times[i + 1];
            // remove adjacent keyframes scheduled at the same time
            if (time !== timeNext && (i !== 1 || time !== times[0])) {
                if (!smoothInterpolation) {
                    // remove unnecessary keyframes same as their neighbors
                    const offset = i * stride, offsetP = offset - stride, offsetN = offset + stride;
                    for(let j = 0; j !== stride; ++j){
                        const value = values[offset + j];
                        if (value !== values[offsetP + j] || value !== values[offsetN + j]) {
                            keep = true;
                            break;
                        }
                    }
                } else keep = true;
            }
            // in-place compaction
            if (keep) {
                if (i !== writeIndex) {
                    times[writeIndex] = times[i];
                    const readOffset = i * stride, writeOffset = writeIndex * stride;
                    for(let j = 0; j !== stride; ++j)values[writeOffset + j] = values[readOffset + j];
                }
                ++writeIndex;
            }
        }
        // flush last keyframe (compaction looks ahead)
        if (lastIndex > 0) {
            times[writeIndex] = times[lastIndex];
            for(let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++j)values[writeOffset + j] = values[readOffset + j];
            ++writeIndex;
        }
        if (writeIndex !== times.length) {
            this.times = times.slice(0, writeIndex);
            this.values = values.slice(0, writeIndex * stride);
        } else {
            this.times = times;
            this.values = values;
        }
        return this;
    }
    clone() {
        const times = this.times.slice();
        const values = this.values.slice();
        const TypedKeyframeTrack = this.constructor;
        const track = new TypedKeyframeTrack(this.name, times, values);
        // Interpolant argument to constructor is not saved, so copy the factory method directly.
        track.createInterpolant = this.createInterpolant;
        return track;
    }
}
$d5b85d29c0b78636$export$b0e479f45b7006d6.prototype.TimeBufferType = Float32Array;
$d5b85d29c0b78636$export$b0e479f45b7006d6.prototype.ValueBufferType = Float32Array;
$d5b85d29c0b78636$export$b0e479f45b7006d6.prototype.DefaultInterpolation = $d5b85d29c0b78636$export$30fac1aace31cf4d;
/**
 * A Track of Boolean keyframe values.
 */ class $d5b85d29c0b78636$export$d3a344b98cf0b775 extends $d5b85d29c0b78636$export$b0e479f45b7006d6 {
    // No interpolation parameter because only InterpolateDiscrete is valid.
    constructor(name, times, values){
        super(name, times, values);
    }
}
$d5b85d29c0b78636$export$d3a344b98cf0b775.prototype.ValueTypeName = 'bool';
$d5b85d29c0b78636$export$d3a344b98cf0b775.prototype.ValueBufferType = Array;
$d5b85d29c0b78636$export$d3a344b98cf0b775.prototype.DefaultInterpolation = $d5b85d29c0b78636$export$995b32462a65e855;
$d5b85d29c0b78636$export$d3a344b98cf0b775.prototype.InterpolantFactoryMethodLinear = undefined;
$d5b85d29c0b78636$export$d3a344b98cf0b775.prototype.InterpolantFactoryMethodSmooth = undefined;
/**
 * A Track of keyframe values that represent color.
 */ class $d5b85d29c0b78636$export$83444c5d885347d8 extends $d5b85d29c0b78636$export$b0e479f45b7006d6 {
}
$d5b85d29c0b78636$export$83444c5d885347d8.prototype.ValueTypeName = 'color';
/**
 * A Track of numeric keyframe values.
 */ class $d5b85d29c0b78636$export$d45f0d1a4d9a9314 extends $d5b85d29c0b78636$export$b0e479f45b7006d6 {
}
$d5b85d29c0b78636$export$d45f0d1a4d9a9314.prototype.ValueTypeName = 'number';
/**
 * Spherical linear unit quaternion interpolant.
 */ class $d5b85d29c0b78636$export$2db1cfb7923d931e extends $d5b85d29c0b78636$export$b558baee9c0f72d3 {
    constructor(parameterPositions, sampleValues, sampleSize, resultBuffer){
        super(parameterPositions, sampleValues, sampleSize, resultBuffer);
    }
    interpolate_(i1, t0, t, t1) {
        const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, alpha = (t - t0) / (t1 - t0);
        let offset = i1 * stride;
        for(let end = offset + stride; offset !== end; offset += 4)$d5b85d29c0b78636$export$23d6a54f0bbc85a3.slerpFlat(result, 0, values, offset - stride, values, offset, alpha);
        return result;
    }
}
/**
 * A Track of quaternion keyframe values.
 */ class $d5b85d29c0b78636$export$b8043f12b5aafbd7 extends $d5b85d29c0b78636$export$b0e479f45b7006d6 {
    InterpolantFactoryMethodLinear(result) {
        return new $d5b85d29c0b78636$export$2db1cfb7923d931e(this.times, this.values, this.getValueSize(), result);
    }
}
$d5b85d29c0b78636$export$b8043f12b5aafbd7.prototype.ValueTypeName = 'quaternion';
// ValueBufferType is inherited
// DefaultInterpolation is inherited;
$d5b85d29c0b78636$export$b8043f12b5aafbd7.prototype.InterpolantFactoryMethodSmooth = undefined;
/**
 * A Track that interpolates Strings
 */ class $d5b85d29c0b78636$export$6ce41d4f3a8df9cd extends $d5b85d29c0b78636$export$b0e479f45b7006d6 {
    // No interpolation parameter because only InterpolateDiscrete is valid.
    constructor(name, times, values){
        super(name, times, values);
    }
}
$d5b85d29c0b78636$export$6ce41d4f3a8df9cd.prototype.ValueTypeName = 'string';
$d5b85d29c0b78636$export$6ce41d4f3a8df9cd.prototype.ValueBufferType = Array;
$d5b85d29c0b78636$export$6ce41d4f3a8df9cd.prototype.DefaultInterpolation = $d5b85d29c0b78636$export$995b32462a65e855;
$d5b85d29c0b78636$export$6ce41d4f3a8df9cd.prototype.InterpolantFactoryMethodLinear = undefined;
$d5b85d29c0b78636$export$6ce41d4f3a8df9cd.prototype.InterpolantFactoryMethodSmooth = undefined;
/**
 * A Track of vectored keyframe values.
 */ class $d5b85d29c0b78636$export$5ce2dcb4cc9f2bff extends $d5b85d29c0b78636$export$b0e479f45b7006d6 {
}
$d5b85d29c0b78636$export$5ce2dcb4cc9f2bff.prototype.ValueTypeName = 'vector';
class $d5b85d29c0b78636$export$d942c706bf23829c {
    constructor(name = '', duration = -1, tracks = [], blendMode = $d5b85d29c0b78636$export$bcfbbdcf8de7f8cd){
        this.name = name;
        this.tracks = tracks;
        this.duration = duration;
        this.blendMode = blendMode;
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        // this means it should figure out its duration by scanning the tracks
        if (this.duration < 0) this.resetDuration();
    }
    static parse(json) {
        const tracks = [], jsonTracks = json.tracks, frameTime = 1.0 / (json.fps || 1.0);
        for(let i = 0, n = jsonTracks.length; i !== n; ++i)tracks.push($d5b85d29c0b78636$var$parseKeyframeTrack(jsonTracks[i]).scale(frameTime));
        const clip = new this(json.name, json.duration, tracks, json.blendMode);
        clip.uuid = json.uuid;
        return clip;
    }
    static toJSON(clip) {
        const tracks = [], clipTracks = clip.tracks;
        const json = {
            'name': clip.name,
            'duration': clip.duration,
            'tracks': tracks,
            'uuid': clip.uuid,
            'blendMode': clip.blendMode
        };
        for(let i = 0, n = clipTracks.length; i !== n; ++i)tracks.push($d5b85d29c0b78636$export$b0e479f45b7006d6.toJSON(clipTracks[i]));
        return json;
    }
    static CreateFromMorphTargetSequence(name, morphTargetSequence, fps, noLoop) {
        const numMorphTargets = morphTargetSequence.length;
        const tracks = [];
        for(let i = 0; i < numMorphTargets; i++){
            let times = [];
            let values = [];
            times.push((i + numMorphTargets - 1) % numMorphTargets, i, (i + 1) % numMorphTargets);
            values.push(0, 1, 0);
            const order = $d5b85d29c0b78636$var$getKeyframeOrder(times);
            times = $d5b85d29c0b78636$var$sortedArray(times, 1, order);
            values = $d5b85d29c0b78636$var$sortedArray(values, 1, order);
            // if there is a key at the first frame, duplicate it as the
            // last frame as well for perfect loop.
            if (!noLoop && times[0] === 0) {
                times.push(numMorphTargets);
                values.push(values[0]);
            }
            tracks.push(new $d5b85d29c0b78636$export$d45f0d1a4d9a9314('.morphTargetInfluences[' + morphTargetSequence[i].name + ']', times, values).scale(1.0 / fps));
        }
        return new this(name, -1, tracks);
    }
    static findByName(objectOrClipArray, name) {
        let clipArray = objectOrClipArray;
        if (!Array.isArray(objectOrClipArray)) {
            const o = objectOrClipArray;
            clipArray = o.geometry && o.geometry.animations || o.animations;
        }
        for(let i = 0; i < clipArray.length; i++){
            if (clipArray[i].name === name) return clipArray[i];
        }
        return null;
    }
    static CreateClipsFromMorphTargetSequences(morphTargets, fps, noLoop) {
        const animationToMorphTargets = {};
        // tested with https://regex101.com/ on trick sequences
        // such flamingo_flyA_003, flamingo_run1_003, crdeath0059
        const pattern = /^([\w-]*?)([\d]+)$/;
        // sort morph target names into animation groups based
        // patterns like Walk_001, Walk_002, Run_001, Run_002
        for(let i = 0, il = morphTargets.length; i < il; i++){
            const morphTarget = morphTargets[i];
            const parts = morphTarget.name.match(pattern);
            if (parts && parts.length > 1) {
                const name = parts[1];
                let animationMorphTargets = animationToMorphTargets[name];
                if (!animationMorphTargets) animationToMorphTargets[name] = animationMorphTargets = [];
                animationMorphTargets.push(morphTarget);
            }
        }
        const clips = [];
        for(const name in animationToMorphTargets)clips.push(this.CreateFromMorphTargetSequence(name, animationToMorphTargets[name], fps, noLoop));
        return clips;
    }
    // parse the animation.hierarchy format
    static parseAnimation(animation, bones) {
        if (!animation) {
            console.error('THREE.AnimationClip: No animation in JSONLoader data.');
            return null;
        }
        const addNonemptyTrack = function(trackType, trackName, animationKeys, propertyName, destTracks) {
            // only return track if there are actually keys.
            if (animationKeys.length !== 0) {
                const times = [];
                const values = [];
                $d5b85d29c0b78636$var$flattenJSON(animationKeys, times, values, propertyName);
                // empty keys are filtered out, so check again
                if (times.length !== 0) destTracks.push(new trackType(trackName, times, values));
            }
        };
        const tracks = [];
        const clipName = animation.name || 'default';
        const fps = animation.fps || 30;
        const blendMode = animation.blendMode;
        // automatic length determination in AnimationClip.
        let duration = animation.length || -1;
        const hierarchyTracks = animation.hierarchy || [];
        for(let h = 0; h < hierarchyTracks.length; h++){
            const animationKeys = hierarchyTracks[h].keys;
            // skip empty tracks
            if (!animationKeys || animationKeys.length === 0) continue;
            // process morph targets
            if (animationKeys[0].morphTargets) {
                // figure out all morph targets used in this track
                const morphTargetNames = {};
                let k;
                for(k = 0; k < animationKeys.length; k++){
                    if (animationKeys[k].morphTargets) for(let m = 0; m < animationKeys[k].morphTargets.length; m++)morphTargetNames[animationKeys[k].morphTargets[m]] = -1;
                }
                // create a track for each morph target with all zero
                // morphTargetInfluences except for the keys in which
                // the morphTarget is named.
                for(const morphTargetName in morphTargetNames){
                    const times = [];
                    const values = [];
                    for(let m = 0; m !== animationKeys[k].morphTargets.length; ++m){
                        const animationKey = animationKeys[k];
                        times.push(animationKey.time);
                        values.push(animationKey.morphTarget === morphTargetName ? 1 : 0);
                    }
                    tracks.push(new $d5b85d29c0b78636$export$d45f0d1a4d9a9314('.morphTargetInfluence[' + morphTargetName + ']', times, values));
                }
                duration = morphTargetNames.length * fps;
            } else {
                // ...assume skeletal animation
                const boneName = '.bones[' + bones[h].name + ']';
                addNonemptyTrack($d5b85d29c0b78636$export$5ce2dcb4cc9f2bff, boneName + '.position', animationKeys, 'pos', tracks);
                addNonemptyTrack($d5b85d29c0b78636$export$b8043f12b5aafbd7, boneName + '.quaternion', animationKeys, 'rot', tracks);
                addNonemptyTrack($d5b85d29c0b78636$export$5ce2dcb4cc9f2bff, boneName + '.scale', animationKeys, 'scl', tracks);
            }
        }
        if (tracks.length === 0) return null;
        const clip = new this(clipName, duration, tracks, blendMode);
        return clip;
    }
    resetDuration() {
        const tracks = this.tracks;
        let duration = 0;
        for(let i = 0, n = tracks.length; i !== n; ++i){
            const track = this.tracks[i];
            duration = Math.max(duration, track.times[track.times.length - 1]);
        }
        this.duration = duration;
        return this;
    }
    trim() {
        for(let i = 0; i < this.tracks.length; i++)this.tracks[i].trim(0, this.duration);
        return this;
    }
    validate() {
        let valid = true;
        for(let i = 0; i < this.tracks.length; i++)valid = valid && this.tracks[i].validate();
        return valid;
    }
    optimize() {
        for(let i = 0; i < this.tracks.length; i++)this.tracks[i].optimize();
        return this;
    }
    clone() {
        const tracks = [];
        for(let i = 0; i < this.tracks.length; i++)tracks.push(this.tracks[i].clone());
        return new this.constructor(this.name, this.duration, tracks, this.blendMode);
    }
    toJSON() {
        return this.constructor.toJSON(this);
    }
}
function $d5b85d29c0b78636$var$getTrackTypeForValueTypeName(typeName) {
    switch(typeName.toLowerCase()){
        case 'scalar':
        case 'double':
        case 'float':
        case 'number':
        case 'integer':
            return $d5b85d29c0b78636$export$d45f0d1a4d9a9314;
        case 'vector':
        case 'vector2':
        case 'vector3':
        case 'vector4':
            return $d5b85d29c0b78636$export$5ce2dcb4cc9f2bff;
        case 'color':
            return $d5b85d29c0b78636$export$83444c5d885347d8;
        case 'quaternion':
            return $d5b85d29c0b78636$export$b8043f12b5aafbd7;
        case 'bool':
        case 'boolean':
            return $d5b85d29c0b78636$export$d3a344b98cf0b775;
        case 'string':
            return $d5b85d29c0b78636$export$6ce41d4f3a8df9cd;
    }
    throw new Error('THREE.KeyframeTrack: Unsupported typeName: ' + typeName);
}
function $d5b85d29c0b78636$var$parseKeyframeTrack(json) {
    if (json.type === undefined) throw new Error('THREE.KeyframeTrack: track type undefined, can not parse');
    const trackType = $d5b85d29c0b78636$var$getTrackTypeForValueTypeName(json.type);
    if (json.times === undefined) {
        const times = [], values = [];
        $d5b85d29c0b78636$var$flattenJSON(json.keys, times, values, 'value');
        json.times = times;
        json.values = values;
    }
    // derived classes can define a static parse method
    if (trackType.parse !== undefined) return trackType.parse(json);
    else // by default, we assume a constructor compatible with the base
    return new trackType(json.name, json.times, json.values, json.interpolation);
}
const $d5b85d29c0b78636$export$94affb487e701bf2 = {
    enabled: false,
    files: {},
    add: function(key, file) {
        if (this.enabled === false) return;
        // console.log( 'THREE.Cache', 'Adding key:', key );
        this.files[key] = file;
    },
    get: function(key) {
        if (this.enabled === false) return;
        // console.log( 'THREE.Cache', 'Checking key:', key );
        return this.files[key];
    },
    remove: function(key) {
        delete this.files[key];
    },
    clear: function() {
        this.files = {};
    }
};
class $d5b85d29c0b78636$export$99cc795e99919eed {
    constructor(onLoad, onProgress, onError){
        const scope = this;
        let isLoading = false;
        let itemsLoaded = 0;
        let itemsTotal = 0;
        let urlModifier = undefined;
        const handlers = [];
        // Refer to #5689 for the reason why we don't set .onStart
        // in the constructor
        this.onStart = undefined;
        this.onLoad = onLoad;
        this.onProgress = onProgress;
        this.onError = onError;
        this.itemStart = function(url) {
            itemsTotal++;
            if (isLoading === false) {
                if (scope.onStart !== undefined) scope.onStart(url, itemsLoaded, itemsTotal);
            }
            isLoading = true;
        };
        this.itemEnd = function(url) {
            itemsLoaded++;
            if (scope.onProgress !== undefined) scope.onProgress(url, itemsLoaded, itemsTotal);
            if (itemsLoaded === itemsTotal) {
                isLoading = false;
                if (scope.onLoad !== undefined) scope.onLoad();
            }
        };
        this.itemError = function(url) {
            if (scope.onError !== undefined) scope.onError(url);
        };
        this.resolveURL = function(url) {
            if (urlModifier) return urlModifier(url);
            return url;
        };
        this.setURLModifier = function(transform) {
            urlModifier = transform;
            return this;
        };
        this.addHandler = function(regex, loader) {
            handlers.push(regex, loader);
            return this;
        };
        this.removeHandler = function(regex) {
            const index = handlers.indexOf(regex);
            if (index !== -1) handlers.splice(index, 2);
            return this;
        };
        this.getHandler = function(file) {
            for(let i = 0, l = handlers.length; i < l; i += 2){
                const regex = handlers[i];
                const loader = handlers[i + 1];
                if (regex.global) regex.lastIndex = 0; // see #17920
                if (regex.test(file)) return loader;
            }
            return null;
        };
    }
}
const $d5b85d29c0b78636$export$b033c3f9a95c6a16 = /*@__PURE__*/ new $d5b85d29c0b78636$export$99cc795e99919eed();
class $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        this.manager = manager !== undefined ? manager : $d5b85d29c0b78636$export$b033c3f9a95c6a16;
        this.crossOrigin = 'anonymous';
        this.withCredentials = false;
        this.path = '';
        this.resourcePath = '';
        this.requestHeader = {};
    }
    load() {}
    loadAsync(url, onProgress) {
        const scope = this;
        return new Promise(function(resolve, reject) {
            scope.load(url, resolve, onProgress, reject);
        });
    }
    parse() {}
    setCrossOrigin(crossOrigin) {
        this.crossOrigin = crossOrigin;
        return this;
    }
    setWithCredentials(value) {
        this.withCredentials = value;
        return this;
    }
    setPath(path) {
        this.path = path;
        return this;
    }
    setResourcePath(resourcePath) {
        this.resourcePath = resourcePath;
        return this;
    }
    setRequestHeader(requestHeader) {
        this.requestHeader = requestHeader;
        return this;
    }
}
$d5b85d29c0b78636$export$3b0d6d7590275603.DEFAULT_MATERIAL_NAME = '__DEFAULT';
const $d5b85d29c0b78636$var$loading = {};
class $d5b85d29c0b78636$var$HttpError extends Error {
    constructor(message, response){
        super(message);
        this.response = response;
    }
}
class $d5b85d29c0b78636$export$98435a25b5cf7b2b extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        if (url === undefined) url = '';
        if (this.path !== undefined) url = this.path + url;
        url = this.manager.resolveURL(url);
        const cached = $d5b85d29c0b78636$export$94affb487e701bf2.get(url);
        if (cached !== undefined) {
            this.manager.itemStart(url);
            setTimeout(()=>{
                if (onLoad) onLoad(cached);
                this.manager.itemEnd(url);
            }, 0);
            return cached;
        }
        // Check if request is duplicate
        if ($d5b85d29c0b78636$var$loading[url] !== undefined) {
            $d5b85d29c0b78636$var$loading[url].push({
                onLoad: onLoad,
                onProgress: onProgress,
                onError: onError
            });
            return;
        }
        // Initialise array for duplicate requests
        $d5b85d29c0b78636$var$loading[url] = [];
        $d5b85d29c0b78636$var$loading[url].push({
            onLoad: onLoad,
            onProgress: onProgress,
            onError: onError
        });
        // create request
        const req = new Request(url, {
            headers: new Headers(this.requestHeader),
            credentials: this.withCredentials ? 'include' : 'same-origin'
        });
        // record states ( avoid data race )
        const mimeType = this.mimeType;
        const responseType = this.responseType;
        // start the fetch
        fetch(req).then((response)=>{
            if (response.status === 200 || response.status === 0) {
                // Some browsers return HTTP Status 0 when using non-http protocol
                // e.g. 'file://' or 'data://'. Handle as success.
                if (response.status === 0) console.warn('THREE.FileLoader: HTTP Status 0 received.');
                // Workaround: Checking if response.body === undefined for Alipay browser #23548
                if (typeof ReadableStream === 'undefined' || response.body === undefined || response.body.getReader === undefined) return response;
                const callbacks = $d5b85d29c0b78636$var$loading[url];
                const reader = response.body.getReader();
                // Nginx needs X-File-Size check
                // https://serverfault.com/questions/482875/why-does-nginx-remove-content-length-header-for-chunked-content
                const contentLength = response.headers.get('X-File-Size') || response.headers.get('Content-Length');
                const total = contentLength ? parseInt(contentLength) : 0;
                const lengthComputable = total !== 0;
                let loaded = 0;
                // periodically read data into the new stream tracking while download progress
                const stream = new ReadableStream({
                    start (controller) {
                        readData();
                        function readData() {
                            reader.read().then(({ done: done, value: value })=>{
                                if (done) controller.close();
                                else {
                                    loaded += value.byteLength;
                                    const event = new ProgressEvent('progress', {
                                        lengthComputable: lengthComputable,
                                        loaded: loaded,
                                        total: total
                                    });
                                    for(let i = 0, il = callbacks.length; i < il; i++){
                                        const callback = callbacks[i];
                                        if (callback.onProgress) callback.onProgress(event);
                                    }
                                    controller.enqueue(value);
                                    readData();
                                }
                            }, (e)=>{
                                controller.error(e);
                            });
                        }
                    }
                });
                return new Response(stream);
            } else throw new $d5b85d29c0b78636$var$HttpError(`fetch for "${response.url}" responded with ${response.status}: ${response.statusText}`, response);
        }).then((response)=>{
            switch(responseType){
                case 'arraybuffer':
                    return response.arrayBuffer();
                case 'blob':
                    return response.blob();
                case 'document':
                    return response.text().then((text)=>{
                        const parser = new DOMParser();
                        return parser.parseFromString(text, mimeType);
                    });
                case 'json':
                    return response.json();
                default:
                    if (mimeType === undefined) return response.text();
                    else {
                        // sniff encoding
                        const re = /charset="?([^;"\s]*)"?/i;
                        const exec = re.exec(mimeType);
                        const label = exec && exec[1] ? exec[1].toLowerCase() : undefined;
                        const decoder = new TextDecoder(label);
                        return response.arrayBuffer().then((ab)=>decoder.decode(ab));
                    }
            }
        }).then((data)=>{
            // Add to cache only on HTTP success, so that we do not cache
            // error response bodies as proper responses to requests.
            $d5b85d29c0b78636$export$94affb487e701bf2.add(url, data);
            const callbacks = $d5b85d29c0b78636$var$loading[url];
            delete $d5b85d29c0b78636$var$loading[url];
            for(let i = 0, il = callbacks.length; i < il; i++){
                const callback = callbacks[i];
                if (callback.onLoad) callback.onLoad(data);
            }
        }).catch((err)=>{
            // Abort errors and other errors are handled the same
            const callbacks = $d5b85d29c0b78636$var$loading[url];
            if (callbacks === undefined) {
                // When onLoad was called and url was deleted in `loading`
                this.manager.itemError(url);
                throw err;
            }
            delete $d5b85d29c0b78636$var$loading[url];
            for(let i = 0, il = callbacks.length; i < il; i++){
                const callback = callbacks[i];
                if (callback.onError) callback.onError(err);
            }
            this.manager.itemError(url);
        }).finally(()=>{
            this.manager.itemEnd(url);
        });
        this.manager.itemStart(url);
    }
    setResponseType(value) {
        this.responseType = value;
        return this;
    }
    setMimeType(value) {
        this.mimeType = value;
        return this;
    }
}
class $d5b85d29c0b78636$export$29711c7e14f61db extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(this.manager);
        loader.setPath(this.path);
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(this.withCredentials);
        loader.load(url, function(text) {
            try {
                onLoad(scope.parse(JSON.parse(text)));
            } catch (e) {
                if (onError) onError(e);
                else console.error(e);
                scope.manager.itemError(url);
            }
        }, onProgress, onError);
    }
    parse(json) {
        const animations = [];
        for(let i = 0; i < json.length; i++){
            const clip = $d5b85d29c0b78636$export$d942c706bf23829c.parse(json[i]);
            animations.push(clip);
        }
        return animations;
    }
}
/**
 * Abstract Base class to block based textures loader (dds, pvr, ...)
 *
 * Sub classes have to implement the parse() method which will be used in load().
 */ class $d5b85d29c0b78636$export$bd73ce947a280350 extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const images = [];
        const texture = new $d5b85d29c0b78636$export$3466bac9141a5cc4();
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(this.manager);
        loader.setPath(this.path);
        loader.setResponseType('arraybuffer');
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(scope.withCredentials);
        let loaded = 0;
        function loadTexture(i) {
            loader.load(url[i], function(buffer) {
                const texDatas = scope.parse(buffer, true);
                images[i] = {
                    width: texDatas.width,
                    height: texDatas.height,
                    format: texDatas.format,
                    mipmaps: texDatas.mipmaps
                };
                loaded += 1;
                if (loaded === 6) {
                    if (texDatas.mipmapCount === 1) texture.minFilter = $d5b85d29c0b78636$export$8a72f490b25c56c8;
                    texture.image = images;
                    texture.format = texDatas.format;
                    texture.needsUpdate = true;
                    if (onLoad) onLoad(texture);
                }
            }, onProgress, onError);
        }
        if (Array.isArray(url)) for(let i = 0, il = url.length; i < il; ++i)loadTexture(i);
        else // compressed cubemap texture stored in a single DDS file
        loader.load(url, function(buffer) {
            const texDatas = scope.parse(buffer, true);
            if (texDatas.isCubemap) {
                const faces = texDatas.mipmaps.length / texDatas.mipmapCount;
                for(let f = 0; f < faces; f++){
                    images[f] = {
                        mipmaps: []
                    };
                    for(let i = 0; i < texDatas.mipmapCount; i++){
                        images[f].mipmaps.push(texDatas.mipmaps[f * texDatas.mipmapCount + i]);
                        images[f].format = texDatas.format;
                        images[f].width = texDatas.width;
                        images[f].height = texDatas.height;
                    }
                }
                texture.image = images;
            } else {
                texture.image.width = texDatas.width;
                texture.image.height = texDatas.height;
                texture.mipmaps = texDatas.mipmaps;
            }
            if (texDatas.mipmapCount === 1) texture.minFilter = $d5b85d29c0b78636$export$8a72f490b25c56c8;
            texture.format = texDatas.format;
            texture.needsUpdate = true;
            if (onLoad) onLoad(texture);
        }, onProgress, onError);
        return texture;
    }
}
class $d5b85d29c0b78636$export$8905ce1c7a2464a1 extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        if (this.path !== undefined) url = this.path + url;
        url = this.manager.resolveURL(url);
        const scope = this;
        const cached = $d5b85d29c0b78636$export$94affb487e701bf2.get(url);
        if (cached !== undefined) {
            scope.manager.itemStart(url);
            setTimeout(function() {
                if (onLoad) onLoad(cached);
                scope.manager.itemEnd(url);
            }, 0);
            return cached;
        }
        const image = $d5b85d29c0b78636$export$7094a064528c7fee('img');
        function onImageLoad() {
            removeEventListeners();
            $d5b85d29c0b78636$export$94affb487e701bf2.add(url, this);
            if (onLoad) onLoad(this);
            scope.manager.itemEnd(url);
        }
        function onImageError(event) {
            removeEventListeners();
            if (onError) onError(event);
            scope.manager.itemError(url);
            scope.manager.itemEnd(url);
        }
        function removeEventListeners() {
            image.removeEventListener('load', onImageLoad, false);
            image.removeEventListener('error', onImageError, false);
        }
        image.addEventListener('load', onImageLoad, false);
        image.addEventListener('error', onImageError, false);
        if (url.slice(0, 5) !== 'data:') {
            if (this.crossOrigin !== undefined) image.crossOrigin = this.crossOrigin;
        }
        scope.manager.itemStart(url);
        image.src = url;
        return image;
    }
}
class $d5b85d29c0b78636$export$2ec114afc2cf6308 extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(urls, onLoad, onProgress, onError) {
        const texture = new $d5b85d29c0b78636$export$ee2e5a18258a4049();
        texture.colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa;
        const loader = new $d5b85d29c0b78636$export$8905ce1c7a2464a1(this.manager);
        loader.setCrossOrigin(this.crossOrigin);
        loader.setPath(this.path);
        let loaded = 0;
        function loadTexture(i) {
            loader.load(urls[i], function(image) {
                texture.images[i] = image;
                loaded++;
                if (loaded === 6) {
                    texture.needsUpdate = true;
                    if (onLoad) onLoad(texture);
                }
            }, undefined, onError);
        }
        for(let i = 0; i < urls.length; ++i)loadTexture(i);
        return texture;
    }
}
/**
 * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
 *
 * Sub classes have to implement the parse() method which will be used in load().
 */ class $d5b85d29c0b78636$export$792d8a18f2c55855 extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const texture = new $d5b85d29c0b78636$export$b691f601014eabe1();
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(this.manager);
        loader.setResponseType('arraybuffer');
        loader.setRequestHeader(this.requestHeader);
        loader.setPath(this.path);
        loader.setWithCredentials(scope.withCredentials);
        loader.load(url, function(buffer) {
            let texData;
            try {
                texData = scope.parse(buffer);
            } catch (error) {
                if (onError !== undefined) onError(error);
                else {
                    console.error(error);
                    return;
                }
            }
            if (texData.image !== undefined) texture.image = texData.image;
            else if (texData.data !== undefined) {
                texture.image.width = texData.width;
                texture.image.height = texData.height;
                texture.image.data = texData.data;
            }
            texture.wrapS = texData.wrapS !== undefined ? texData.wrapS : $d5b85d29c0b78636$export$9d9334239a5a5e06;
            texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : $d5b85d29c0b78636$export$9d9334239a5a5e06;
            texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : $d5b85d29c0b78636$export$8a72f490b25c56c8;
            texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : $d5b85d29c0b78636$export$8a72f490b25c56c8;
            texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;
            if (texData.colorSpace !== undefined) texture.colorSpace = texData.colorSpace;
            if (texData.flipY !== undefined) texture.flipY = texData.flipY;
            if (texData.format !== undefined) texture.format = texData.format;
            if (texData.type !== undefined) texture.type = texData.type;
            if (texData.mipmaps !== undefined) {
                texture.mipmaps = texData.mipmaps;
                texture.minFilter = $d5b85d29c0b78636$export$5d8599b6a933fb1b; // presumably...
            }
            if (texData.mipmapCount === 1) texture.minFilter = $d5b85d29c0b78636$export$8a72f490b25c56c8;
            if (texData.generateMipmaps !== undefined) texture.generateMipmaps = texData.generateMipmaps;
            texture.needsUpdate = true;
            if (onLoad) onLoad(texture, texData);
        }, onProgress, onError);
        return texture;
    }
}
class $d5b85d29c0b78636$export$fd1bfc71f64c538c extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const texture = new $d5b85d29c0b78636$export$5431306cf43de24a();
        const loader = new $d5b85d29c0b78636$export$8905ce1c7a2464a1(this.manager);
        loader.setCrossOrigin(this.crossOrigin);
        loader.setPath(this.path);
        loader.load(url, function(image) {
            texture.image = image;
            texture.needsUpdate = true;
            if (onLoad !== undefined) onLoad(texture);
        }, onProgress, onError);
        return texture;
    }
}
class $d5b85d29c0b78636$export$6ecadb6ed240d696 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(color, intensity = 1){
        super();
        this.isLight = true;
        this.type = 'Light';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e(color);
        this.intensity = intensity;
    }
    dispose() {
    // Empty here in base class; some subclasses override.
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.color.copy(source.color);
        this.intensity = source.intensity;
        return this;
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        data.object.color = this.color.getHex();
        data.object.intensity = this.intensity;
        if (this.groundColor !== undefined) data.object.groundColor = this.groundColor.getHex();
        if (this.distance !== undefined) data.object.distance = this.distance;
        if (this.angle !== undefined) data.object.angle = this.angle;
        if (this.decay !== undefined) data.object.decay = this.decay;
        if (this.penumbra !== undefined) data.object.penumbra = this.penumbra;
        if (this.shadow !== undefined) data.object.shadow = this.shadow.toJSON();
        if (this.target !== undefined) data.object.target = this.target.uuid;
        return data;
    }
}
class $d5b85d29c0b78636$export$8d474f55edbb9624 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(skyColor, groundColor, intensity){
        super(skyColor, intensity);
        this.isHemisphereLight = true;
        this.type = 'HemisphereLight';
        this.position.copy($d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_UP);
        this.updateMatrix();
        this.groundColor = new $d5b85d29c0b78636$export$892596cec99bc70e(groundColor);
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.groundColor.copy(source.groundColor);
        return this;
    }
}
const $d5b85d29c0b78636$var$_projScreenMatrix$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_lightPositionWorld$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_lookTarget$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$var$LightShadow {
    constructor(camera){
        this.camera = camera;
        this.intensity = 1;
        this.bias = 0;
        this.normalBias = 0;
        this.radius = 1;
        this.blurSamples = 8;
        this.mapSize = new $d5b85d29c0b78636$export$c977b3e384af9ae1(512, 512);
        this.map = null;
        this.mapPass = null;
        this.matrix = new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
        this.autoUpdate = true;
        this.needsUpdate = false;
        this._frustum = new $d5b85d29c0b78636$export$35efe6f4c85463d2();
        this._frameExtents = new $d5b85d29c0b78636$export$c977b3e384af9ae1(1, 1);
        this._viewportCount = 1;
        this._viewports = [
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(0, 0, 1, 1)
        ];
    }
    getViewportCount() {
        return this._viewportCount;
    }
    getFrustum() {
        return this._frustum;
    }
    updateMatrices(light) {
        const shadowCamera = this.camera;
        const shadowMatrix = this.matrix;
        $d5b85d29c0b78636$var$_lightPositionWorld$1.setFromMatrixPosition(light.matrixWorld);
        shadowCamera.position.copy($d5b85d29c0b78636$var$_lightPositionWorld$1);
        $d5b85d29c0b78636$var$_lookTarget$1.setFromMatrixPosition(light.target.matrixWorld);
        shadowCamera.lookAt($d5b85d29c0b78636$var$_lookTarget$1);
        shadowCamera.updateMatrixWorld();
        $d5b85d29c0b78636$var$_projScreenMatrix$1.multiplyMatrices(shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse);
        this._frustum.setFromProjectionMatrix($d5b85d29c0b78636$var$_projScreenMatrix$1);
        shadowMatrix.set(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
        shadowMatrix.multiply($d5b85d29c0b78636$var$_projScreenMatrix$1);
    }
    getViewport(viewportIndex) {
        return this._viewports[viewportIndex];
    }
    getFrameExtents() {
        return this._frameExtents;
    }
    dispose() {
        if (this.map) this.map.dispose();
        if (this.mapPass) this.mapPass.dispose();
    }
    copy(source) {
        this.camera = source.camera.clone();
        this.intensity = source.intensity;
        this.bias = source.bias;
        this.radius = source.radius;
        this.mapSize.copy(source.mapSize);
        return this;
    }
    clone() {
        return new this.constructor().copy(this);
    }
    toJSON() {
        const object = {};
        if (this.intensity !== 1) object.intensity = this.intensity;
        if (this.bias !== 0) object.bias = this.bias;
        if (this.normalBias !== 0) object.normalBias = this.normalBias;
        if (this.radius !== 1) object.radius = this.radius;
        if (this.mapSize.x !== 512 || this.mapSize.y !== 512) object.mapSize = this.mapSize.toArray();
        object.camera = this.camera.toJSON(false).object;
        delete object.camera.matrix;
        return object;
    }
}
class $d5b85d29c0b78636$var$SpotLightShadow extends $d5b85d29c0b78636$var$LightShadow {
    constructor(){
        super(new $d5b85d29c0b78636$export$74e4ae24825f68d7(50, 1, 0.5, 500));
        this.isSpotLightShadow = true;
        this.focus = 1;
    }
    updateMatrices(light) {
        const camera = this.camera;
        const fov = $d5b85d29c0b78636$export$914076c8150813e5 * 2 * light.angle * this.focus;
        const aspect = this.mapSize.width / this.mapSize.height;
        const far = light.distance || camera.far;
        if (fov !== camera.fov || aspect !== camera.aspect || far !== camera.far) {
            camera.fov = fov;
            camera.aspect = aspect;
            camera.far = far;
            camera.updateProjectionMatrix();
        }
        super.updateMatrices(light);
    }
    copy(source) {
        super.copy(source);
        this.focus = source.focus;
        return this;
    }
}
class $d5b85d29c0b78636$export$81495cbb73897362 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(color, intensity, distance = 0, angle = Math.PI / 3, penumbra = 0, decay = 2){
        super(color, intensity);
        this.isSpotLight = true;
        this.type = 'SpotLight';
        this.position.copy($d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_UP);
        this.updateMatrix();
        this.target = new $d5b85d29c0b78636$export$e4dd07dff30cc924();
        this.distance = distance;
        this.angle = angle;
        this.penumbra = penumbra;
        this.decay = decay;
        this.map = null;
        this.shadow = new $d5b85d29c0b78636$var$SpotLightShadow();
    }
    get power() {
        // compute the light's luminous power (in lumens) from its intensity (in candela)
        // by convention for a spotlight, luminous power (lm) = π * luminous intensity (cd)
        return this.intensity * Math.PI;
    }
    set power(power) {
        // set the light's intensity (in candela) from the desired luminous power (in lumens)
        this.intensity = power / Math.PI;
    }
    dispose() {
        this.shadow.dispose();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.distance = source.distance;
        this.angle = source.angle;
        this.penumbra = source.penumbra;
        this.decay = source.decay;
        this.target = source.target.clone();
        this.shadow = source.shadow.clone();
        return this;
    }
}
const $d5b85d29c0b78636$var$_projScreenMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_lightPositionWorld = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_lookTarget = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$var$PointLightShadow extends $d5b85d29c0b78636$var$LightShadow {
    constructor(){
        super(new $d5b85d29c0b78636$export$74e4ae24825f68d7(90, 1, 0.5, 500));
        this.isPointLightShadow = true;
        this._frameExtents = new $d5b85d29c0b78636$export$c977b3e384af9ae1(4, 2);
        this._viewportCount = 6;
        this._viewports = [
            // These viewports map a cube-map onto a 2D texture with the
            // following orientation:
            //
            //  xzXZ
            //   y Y
            //
            // X - Positive x direction
            // x - Negative x direction
            // Y - Positive y direction
            // y - Negative y direction
            // Z - Positive z direction
            // z - Negative z direction
            // positive X
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(2, 1, 1, 1),
            // negative X
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(0, 1, 1, 1),
            // positive Z
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(3, 1, 1, 1),
            // negative Z
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(1, 1, 1, 1),
            // positive Y
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(3, 0, 1, 1),
            // negative Y
            new $d5b85d29c0b78636$export$fa7daccca11cdbe3(1, 0, 1, 1)
        ];
        this._cubeDirections = [
            new $d5b85d29c0b78636$export$64b5c384219d3699(1, 0, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(-1, 0, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, 1),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, -1),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, -1, 0)
        ];
        this._cubeUps = [
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 1, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, 1),
            new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, -1)
        ];
    }
    updateMatrices(light, viewportIndex = 0) {
        const camera = this.camera;
        const shadowMatrix = this.matrix;
        const far = light.distance || camera.far;
        if (far !== camera.far) {
            camera.far = far;
            camera.updateProjectionMatrix();
        }
        $d5b85d29c0b78636$var$_lightPositionWorld.setFromMatrixPosition(light.matrixWorld);
        camera.position.copy($d5b85d29c0b78636$var$_lightPositionWorld);
        $d5b85d29c0b78636$var$_lookTarget.copy(camera.position);
        $d5b85d29c0b78636$var$_lookTarget.add(this._cubeDirections[viewportIndex]);
        camera.up.copy(this._cubeUps[viewportIndex]);
        camera.lookAt($d5b85d29c0b78636$var$_lookTarget);
        camera.updateMatrixWorld();
        shadowMatrix.makeTranslation(-$d5b85d29c0b78636$var$_lightPositionWorld.x, -$d5b85d29c0b78636$var$_lightPositionWorld.y, -$d5b85d29c0b78636$var$_lightPositionWorld.z);
        $d5b85d29c0b78636$var$_projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
        this._frustum.setFromProjectionMatrix($d5b85d29c0b78636$var$_projScreenMatrix);
    }
}
class $d5b85d29c0b78636$export$4c9c1cb3f0b6f455 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(color, intensity, distance = 0, decay = 2){
        super(color, intensity);
        this.isPointLight = true;
        this.type = 'PointLight';
        this.distance = distance;
        this.decay = decay;
        this.shadow = new $d5b85d29c0b78636$var$PointLightShadow();
    }
    get power() {
        // compute the light's luminous power (in lumens) from its intensity (in candela)
        // for an isotropic light source, luminous power (lm) = 4 π luminous intensity (cd)
        return this.intensity * 4 * Math.PI;
    }
    set power(power) {
        // set the light's intensity (in candela) from the desired luminous power (in lumens)
        this.intensity = power / (4 * Math.PI);
    }
    dispose() {
        this.shadow.dispose();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.distance = source.distance;
        this.decay = source.decay;
        this.shadow = source.shadow.clone();
        return this;
    }
}
class $d5b85d29c0b78636$export$9ebf355ee4ed261b extends $d5b85d29c0b78636$export$79f141de891a5fed {
    constructor(left = -1, right = 1, top = 1, bottom = -1, near = 0.1, far = 2000){
        super();
        this.isOrthographicCamera = true;
        this.type = 'OrthographicCamera';
        this.zoom = 1;
        this.view = null;
        this.left = left;
        this.right = right;
        this.top = top;
        this.bottom = bottom;
        this.near = near;
        this.far = far;
        this.updateProjectionMatrix();
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.left = source.left;
        this.right = source.right;
        this.top = source.top;
        this.bottom = source.bottom;
        this.near = source.near;
        this.far = source.far;
        this.zoom = source.zoom;
        this.view = source.view === null ? null : Object.assign({}, source.view);
        return this;
    }
    setViewOffset(fullWidth, fullHeight, x, y, width, height) {
        if (this.view === null) this.view = {
            enabled: true,
            fullWidth: 1,
            fullHeight: 1,
            offsetX: 0,
            offsetY: 0,
            width: 1,
            height: 1
        };
        this.view.enabled = true;
        this.view.fullWidth = fullWidth;
        this.view.fullHeight = fullHeight;
        this.view.offsetX = x;
        this.view.offsetY = y;
        this.view.width = width;
        this.view.height = height;
        this.updateProjectionMatrix();
    }
    clearViewOffset() {
        if (this.view !== null) this.view.enabled = false;
        this.updateProjectionMatrix();
    }
    updateProjectionMatrix() {
        const dx = (this.right - this.left) / (2 * this.zoom);
        const dy = (this.top - this.bottom) / (2 * this.zoom);
        const cx = (this.right + this.left) / 2;
        const cy = (this.top + this.bottom) / 2;
        let left = cx - dx;
        let right = cx + dx;
        let top = cy + dy;
        let bottom = cy - dy;
        if (this.view !== null && this.view.enabled) {
            const scaleW = (this.right - this.left) / this.view.fullWidth / this.zoom;
            const scaleH = (this.top - this.bottom) / this.view.fullHeight / this.zoom;
            left += scaleW * this.view.offsetX;
            right = left + scaleW * this.view.width;
            top -= scaleH * this.view.offsetY;
            bottom = top - scaleH * this.view.height;
        }
        this.projectionMatrix.makeOrthographic(left, right, top, bottom, this.near, this.far, this.coordinateSystem);
        this.projectionMatrixInverse.copy(this.projectionMatrix).invert();
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        data.object.zoom = this.zoom;
        data.object.left = this.left;
        data.object.right = this.right;
        data.object.top = this.top;
        data.object.bottom = this.bottom;
        data.object.near = this.near;
        data.object.far = this.far;
        if (this.view !== null) data.object.view = Object.assign({}, this.view);
        return data;
    }
}
class $d5b85d29c0b78636$var$DirectionalLightShadow extends $d5b85d29c0b78636$var$LightShadow {
    constructor(){
        super(new $d5b85d29c0b78636$export$9ebf355ee4ed261b(-5, 5, 5, -5, 0.5, 500));
        this.isDirectionalLightShadow = true;
    }
}
class $d5b85d29c0b78636$export$3fea33cc9972c868 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(color, intensity){
        super(color, intensity);
        this.isDirectionalLight = true;
        this.type = 'DirectionalLight';
        this.position.copy($d5b85d29c0b78636$export$e4dd07dff30cc924.DEFAULT_UP);
        this.updateMatrix();
        this.target = new $d5b85d29c0b78636$export$e4dd07dff30cc924();
        this.shadow = new $d5b85d29c0b78636$var$DirectionalLightShadow();
    }
    dispose() {
        this.shadow.dispose();
    }
    copy(source) {
        super.copy(source);
        this.target = source.target.clone();
        this.shadow = source.shadow.clone();
        return this;
    }
}
class $d5b85d29c0b78636$export$af279bfef9ec2c96 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(color, intensity){
        super(color, intensity);
        this.isAmbientLight = true;
        this.type = 'AmbientLight';
    }
}
class $d5b85d29c0b78636$export$61db2d908bbd2429 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(color, intensity, width = 10, height = 10){
        super(color, intensity);
        this.isRectAreaLight = true;
        this.type = 'RectAreaLight';
        this.width = width;
        this.height = height;
    }
    get power() {
        // compute the light's luminous power (in lumens) from its intensity (in nits)
        return this.intensity * this.width * this.height * Math.PI;
    }
    set power(power) {
        // set the light's intensity (in nits) from the desired luminous power (in lumens)
        this.intensity = power / (this.width * this.height * Math.PI);
    }
    copy(source) {
        super.copy(source);
        this.width = source.width;
        this.height = source.height;
        return this;
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        data.object.width = this.width;
        data.object.height = this.height;
        return data;
    }
}
/**
 * Primary reference:
 *   https://graphics.stanford.edu/papers/envmap/envmap.pdf
 *
 * Secondary reference:
 *   https://www.ppsloan.org/publications/StupidSH36.pdf
 */ // 3-band SH defined by 9 coefficients
class $d5b85d29c0b78636$export$ba61ce607e1f405a {
    constructor(){
        this.isSphericalHarmonics3 = true;
        this.coefficients = [];
        for(let i = 0; i < 9; i++)this.coefficients.push(new $d5b85d29c0b78636$export$64b5c384219d3699());
    }
    set(coefficients) {
        for(let i = 0; i < 9; i++)this.coefficients[i].copy(coefficients[i]);
        return this;
    }
    zero() {
        for(let i = 0; i < 9; i++)this.coefficients[i].set(0, 0, 0);
        return this;
    }
    // get the radiance in the direction of the normal
    // target is a Vector3
    getAt(normal, target) {
        // normal is assumed to be unit length
        const x = normal.x, y = normal.y, z = normal.z;
        const coeff = this.coefficients;
        // band 0
        target.copy(coeff[0]).multiplyScalar(0.282095);
        // band 1
        target.addScaledVector(coeff[1], 0.488603 * y);
        target.addScaledVector(coeff[2], 0.488603 * z);
        target.addScaledVector(coeff[3], 0.488603 * x);
        // band 2
        target.addScaledVector(coeff[4], 1.092548 * (x * y));
        target.addScaledVector(coeff[5], 1.092548 * (y * z));
        target.addScaledVector(coeff[6], 0.315392 * (3.0 * z * z - 1.0));
        target.addScaledVector(coeff[7], 1.092548 * (x * z));
        target.addScaledVector(coeff[8], 0.546274 * (x * x - y * y));
        return target;
    }
    // get the irradiance (radiance convolved with cosine lobe) in the direction of the normal
    // target is a Vector3
    // https://graphics.stanford.edu/papers/envmap/envmap.pdf
    getIrradianceAt(normal, target) {
        // normal is assumed to be unit length
        const x = normal.x, y = normal.y, z = normal.z;
        const coeff = this.coefficients;
        // band 0
        target.copy(coeff[0]).multiplyScalar(0.886227); // π * 0.282095
        // band 1
        target.addScaledVector(coeff[1], 1.023328 * y); // ( 2 * π / 3 ) * 0.488603
        target.addScaledVector(coeff[2], 1.023328 * z);
        target.addScaledVector(coeff[3], 1.023328 * x);
        // band 2
        target.addScaledVector(coeff[4], 0.858086 * x * y); // ( π / 4 ) * 1.092548
        target.addScaledVector(coeff[5], 0.858086 * y * z);
        target.addScaledVector(coeff[6], 0.743125 * z * z - 0.247708); // ( π / 4 ) * 0.315392 * 3
        target.addScaledVector(coeff[7], 0.858086 * x * z);
        target.addScaledVector(coeff[8], 0.429043 * (x * x - y * y)); // ( π / 4 ) * 0.546274
        return target;
    }
    add(sh) {
        for(let i = 0; i < 9; i++)this.coefficients[i].add(sh.coefficients[i]);
        return this;
    }
    addScaledSH(sh, s) {
        for(let i = 0; i < 9; i++)this.coefficients[i].addScaledVector(sh.coefficients[i], s);
        return this;
    }
    scale(s) {
        for(let i = 0; i < 9; i++)this.coefficients[i].multiplyScalar(s);
        return this;
    }
    lerp(sh, alpha) {
        for(let i = 0; i < 9; i++)this.coefficients[i].lerp(sh.coefficients[i], alpha);
        return this;
    }
    equals(sh) {
        for(let i = 0; i < 9; i++){
            if (!this.coefficients[i].equals(sh.coefficients[i])) return false;
        }
        return true;
    }
    copy(sh) {
        return this.set(sh.coefficients);
    }
    clone() {
        return new this.constructor().copy(this);
    }
    fromArray(array, offset = 0) {
        const coefficients = this.coefficients;
        for(let i = 0; i < 9; i++)coefficients[i].fromArray(array, offset + i * 3);
        return this;
    }
    toArray(array = [], offset = 0) {
        const coefficients = this.coefficients;
        for(let i = 0; i < 9; i++)coefficients[i].toArray(array, offset + i * 3);
        return array;
    }
    // evaluate the basis functions
    // shBasis is an Array[ 9 ]
    static getBasisAt(normal, shBasis) {
        // normal is assumed to be unit length
        const x = normal.x, y = normal.y, z = normal.z;
        // band 0
        shBasis[0] = 0.282095;
        // band 1
        shBasis[1] = 0.488603 * y;
        shBasis[2] = 0.488603 * z;
        shBasis[3] = 0.488603 * x;
        // band 2
        shBasis[4] = 1.092548 * x * y;
        shBasis[5] = 1.092548 * y * z;
        shBasis[6] = 0.315392 * (3 * z * z - 1);
        shBasis[7] = 1.092548 * x * z;
        shBasis[8] = 0.546274 * (x * x - y * y);
    }
}
class $d5b85d29c0b78636$export$e7ef036e309b38d2 extends $d5b85d29c0b78636$export$6ecadb6ed240d696 {
    constructor(sh = new $d5b85d29c0b78636$export$ba61ce607e1f405a(), intensity = 1){
        super(undefined, intensity);
        this.isLightProbe = true;
        this.sh = sh;
    }
    copy(source) {
        super.copy(source);
        this.sh.copy(source.sh);
        return this;
    }
    fromJSON(json) {
        this.intensity = json.intensity; // TODO: Move this bit to Light.fromJSON();
        this.sh.fromArray(json.sh);
        return this;
    }
    toJSON(meta) {
        const data = super.toJSON(meta);
        data.object.sh = this.sh.toArray();
        return data;
    }
}
class $d5b85d29c0b78636$export$3bd6d323353dcf96 extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
        this.textures = {};
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(scope.manager);
        loader.setPath(scope.path);
        loader.setRequestHeader(scope.requestHeader);
        loader.setWithCredentials(scope.withCredentials);
        loader.load(url, function(text) {
            try {
                onLoad(scope.parse(JSON.parse(text)));
            } catch (e) {
                if (onError) onError(e);
                else console.error(e);
                scope.manager.itemError(url);
            }
        }, onProgress, onError);
    }
    parse(json) {
        const textures = this.textures;
        function getTexture(name) {
            if (textures[name] === undefined) console.warn('THREE.MaterialLoader: Undefined texture', name);
            return textures[name];
        }
        const material = this.createMaterialFromType(json.type);
        if (json.uuid !== undefined) material.uuid = json.uuid;
        if (json.name !== undefined) material.name = json.name;
        if (json.color !== undefined && material.color !== undefined) material.color.setHex(json.color);
        if (json.roughness !== undefined) material.roughness = json.roughness;
        if (json.metalness !== undefined) material.metalness = json.metalness;
        if (json.sheen !== undefined) material.sheen = json.sheen;
        if (json.sheenColor !== undefined) material.sheenColor = new $d5b85d29c0b78636$export$892596cec99bc70e().setHex(json.sheenColor);
        if (json.sheenRoughness !== undefined) material.sheenRoughness = json.sheenRoughness;
        if (json.emissive !== undefined && material.emissive !== undefined) material.emissive.setHex(json.emissive);
        if (json.specular !== undefined && material.specular !== undefined) material.specular.setHex(json.specular);
        if (json.specularIntensity !== undefined) material.specularIntensity = json.specularIntensity;
        if (json.specularColor !== undefined && material.specularColor !== undefined) material.specularColor.setHex(json.specularColor);
        if (json.shininess !== undefined) material.shininess = json.shininess;
        if (json.clearcoat !== undefined) material.clearcoat = json.clearcoat;
        if (json.clearcoatRoughness !== undefined) material.clearcoatRoughness = json.clearcoatRoughness;
        if (json.dispersion !== undefined) material.dispersion = json.dispersion;
        if (json.iridescence !== undefined) material.iridescence = json.iridescence;
        if (json.iridescenceIOR !== undefined) material.iridescenceIOR = json.iridescenceIOR;
        if (json.iridescenceThicknessRange !== undefined) material.iridescenceThicknessRange = json.iridescenceThicknessRange;
        if (json.transmission !== undefined) material.transmission = json.transmission;
        if (json.thickness !== undefined) material.thickness = json.thickness;
        if (json.attenuationDistance !== undefined) material.attenuationDistance = json.attenuationDistance;
        if (json.attenuationColor !== undefined && material.attenuationColor !== undefined) material.attenuationColor.setHex(json.attenuationColor);
        if (json.anisotropy !== undefined) material.anisotropy = json.anisotropy;
        if (json.anisotropyRotation !== undefined) material.anisotropyRotation = json.anisotropyRotation;
        if (json.fog !== undefined) material.fog = json.fog;
        if (json.flatShading !== undefined) material.flatShading = json.flatShading;
        if (json.blending !== undefined) material.blending = json.blending;
        if (json.combine !== undefined) material.combine = json.combine;
        if (json.side !== undefined) material.side = json.side;
        if (json.shadowSide !== undefined) material.shadowSide = json.shadowSide;
        if (json.opacity !== undefined) material.opacity = json.opacity;
        if (json.transparent !== undefined) material.transparent = json.transparent;
        if (json.alphaTest !== undefined) material.alphaTest = json.alphaTest;
        if (json.alphaHash !== undefined) material.alphaHash = json.alphaHash;
        if (json.depthFunc !== undefined) material.depthFunc = json.depthFunc;
        if (json.depthTest !== undefined) material.depthTest = json.depthTest;
        if (json.depthWrite !== undefined) material.depthWrite = json.depthWrite;
        if (json.colorWrite !== undefined) material.colorWrite = json.colorWrite;
        if (json.blendSrc !== undefined) material.blendSrc = json.blendSrc;
        if (json.blendDst !== undefined) material.blendDst = json.blendDst;
        if (json.blendEquation !== undefined) material.blendEquation = json.blendEquation;
        if (json.blendSrcAlpha !== undefined) material.blendSrcAlpha = json.blendSrcAlpha;
        if (json.blendDstAlpha !== undefined) material.blendDstAlpha = json.blendDstAlpha;
        if (json.blendEquationAlpha !== undefined) material.blendEquationAlpha = json.blendEquationAlpha;
        if (json.blendColor !== undefined && material.blendColor !== undefined) material.blendColor.setHex(json.blendColor);
        if (json.blendAlpha !== undefined) material.blendAlpha = json.blendAlpha;
        if (json.stencilWriteMask !== undefined) material.stencilWriteMask = json.stencilWriteMask;
        if (json.stencilFunc !== undefined) material.stencilFunc = json.stencilFunc;
        if (json.stencilRef !== undefined) material.stencilRef = json.stencilRef;
        if (json.stencilFuncMask !== undefined) material.stencilFuncMask = json.stencilFuncMask;
        if (json.stencilFail !== undefined) material.stencilFail = json.stencilFail;
        if (json.stencilZFail !== undefined) material.stencilZFail = json.stencilZFail;
        if (json.stencilZPass !== undefined) material.stencilZPass = json.stencilZPass;
        if (json.stencilWrite !== undefined) material.stencilWrite = json.stencilWrite;
        if (json.wireframe !== undefined) material.wireframe = json.wireframe;
        if (json.wireframeLinewidth !== undefined) material.wireframeLinewidth = json.wireframeLinewidth;
        if (json.wireframeLinecap !== undefined) material.wireframeLinecap = json.wireframeLinecap;
        if (json.wireframeLinejoin !== undefined) material.wireframeLinejoin = json.wireframeLinejoin;
        if (json.rotation !== undefined) material.rotation = json.rotation;
        if (json.linewidth !== undefined) material.linewidth = json.linewidth;
        if (json.dashSize !== undefined) material.dashSize = json.dashSize;
        if (json.gapSize !== undefined) material.gapSize = json.gapSize;
        if (json.scale !== undefined) material.scale = json.scale;
        if (json.polygonOffset !== undefined) material.polygonOffset = json.polygonOffset;
        if (json.polygonOffsetFactor !== undefined) material.polygonOffsetFactor = json.polygonOffsetFactor;
        if (json.polygonOffsetUnits !== undefined) material.polygonOffsetUnits = json.polygonOffsetUnits;
        if (json.dithering !== undefined) material.dithering = json.dithering;
        if (json.alphaToCoverage !== undefined) material.alphaToCoverage = json.alphaToCoverage;
        if (json.premultipliedAlpha !== undefined) material.premultipliedAlpha = json.premultipliedAlpha;
        if (json.forceSinglePass !== undefined) material.forceSinglePass = json.forceSinglePass;
        if (json.visible !== undefined) material.visible = json.visible;
        if (json.toneMapped !== undefined) material.toneMapped = json.toneMapped;
        if (json.userData !== undefined) material.userData = json.userData;
        if (json.vertexColors !== undefined) {
            if (typeof json.vertexColors === 'number') material.vertexColors = json.vertexColors > 0 ? true : false;
            else material.vertexColors = json.vertexColors;
        }
        // Shader Material
        if (json.uniforms !== undefined) for(const name in json.uniforms){
            const uniform = json.uniforms[name];
            material.uniforms[name] = {};
            switch(uniform.type){
                case 't':
                    material.uniforms[name].value = getTexture(uniform.value);
                    break;
                case 'c':
                    material.uniforms[name].value = new $d5b85d29c0b78636$export$892596cec99bc70e().setHex(uniform.value);
                    break;
                case 'v2':
                    material.uniforms[name].value = new $d5b85d29c0b78636$export$c977b3e384af9ae1().fromArray(uniform.value);
                    break;
                case 'v3':
                    material.uniforms[name].value = new $d5b85d29c0b78636$export$64b5c384219d3699().fromArray(uniform.value);
                    break;
                case 'v4':
                    material.uniforms[name].value = new $d5b85d29c0b78636$export$fa7daccca11cdbe3().fromArray(uniform.value);
                    break;
                case 'm3':
                    material.uniforms[name].value = new $d5b85d29c0b78636$export$8ff26dafa08918().fromArray(uniform.value);
                    break;
                case 'm4':
                    material.uniforms[name].value = new $d5b85d29c0b78636$export$2ae72fc923e5eb5().fromArray(uniform.value);
                    break;
                default:
                    material.uniforms[name].value = uniform.value;
            }
        }
        if (json.defines !== undefined) material.defines = json.defines;
        if (json.vertexShader !== undefined) material.vertexShader = json.vertexShader;
        if (json.fragmentShader !== undefined) material.fragmentShader = json.fragmentShader;
        if (json.glslVersion !== undefined) material.glslVersion = json.glslVersion;
        if (json.extensions !== undefined) for(const key in json.extensions)material.extensions[key] = json.extensions[key];
        if (json.lights !== undefined) material.lights = json.lights;
        if (json.clipping !== undefined) material.clipping = json.clipping;
        // for PointsMaterial
        if (json.size !== undefined) material.size = json.size;
        if (json.sizeAttenuation !== undefined) material.sizeAttenuation = json.sizeAttenuation;
        // maps
        if (json.map !== undefined) material.map = getTexture(json.map);
        if (json.matcap !== undefined) material.matcap = getTexture(json.matcap);
        if (json.alphaMap !== undefined) material.alphaMap = getTexture(json.alphaMap);
        if (json.bumpMap !== undefined) material.bumpMap = getTexture(json.bumpMap);
        if (json.bumpScale !== undefined) material.bumpScale = json.bumpScale;
        if (json.normalMap !== undefined) material.normalMap = getTexture(json.normalMap);
        if (json.normalMapType !== undefined) material.normalMapType = json.normalMapType;
        if (json.normalScale !== undefined) {
            let normalScale = json.normalScale;
            if (Array.isArray(normalScale) === false) // Blender exporter used to export a scalar. See #7459
            normalScale = [
                normalScale,
                normalScale
            ];
            material.normalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1().fromArray(normalScale);
        }
        if (json.displacementMap !== undefined) material.displacementMap = getTexture(json.displacementMap);
        if (json.displacementScale !== undefined) material.displacementScale = json.displacementScale;
        if (json.displacementBias !== undefined) material.displacementBias = json.displacementBias;
        if (json.roughnessMap !== undefined) material.roughnessMap = getTexture(json.roughnessMap);
        if (json.metalnessMap !== undefined) material.metalnessMap = getTexture(json.metalnessMap);
        if (json.emissiveMap !== undefined) material.emissiveMap = getTexture(json.emissiveMap);
        if (json.emissiveIntensity !== undefined) material.emissiveIntensity = json.emissiveIntensity;
        if (json.specularMap !== undefined) material.specularMap = getTexture(json.specularMap);
        if (json.specularIntensityMap !== undefined) material.specularIntensityMap = getTexture(json.specularIntensityMap);
        if (json.specularColorMap !== undefined) material.specularColorMap = getTexture(json.specularColorMap);
        if (json.envMap !== undefined) material.envMap = getTexture(json.envMap);
        if (json.envMapRotation !== undefined) material.envMapRotation.fromArray(json.envMapRotation);
        if (json.envMapIntensity !== undefined) material.envMapIntensity = json.envMapIntensity;
        if (json.reflectivity !== undefined) material.reflectivity = json.reflectivity;
        if (json.refractionRatio !== undefined) material.refractionRatio = json.refractionRatio;
        if (json.lightMap !== undefined) material.lightMap = getTexture(json.lightMap);
        if (json.lightMapIntensity !== undefined) material.lightMapIntensity = json.lightMapIntensity;
        if (json.aoMap !== undefined) material.aoMap = getTexture(json.aoMap);
        if (json.aoMapIntensity !== undefined) material.aoMapIntensity = json.aoMapIntensity;
        if (json.gradientMap !== undefined) material.gradientMap = getTexture(json.gradientMap);
        if (json.clearcoatMap !== undefined) material.clearcoatMap = getTexture(json.clearcoatMap);
        if (json.clearcoatRoughnessMap !== undefined) material.clearcoatRoughnessMap = getTexture(json.clearcoatRoughnessMap);
        if (json.clearcoatNormalMap !== undefined) material.clearcoatNormalMap = getTexture(json.clearcoatNormalMap);
        if (json.clearcoatNormalScale !== undefined) material.clearcoatNormalScale = new $d5b85d29c0b78636$export$c977b3e384af9ae1().fromArray(json.clearcoatNormalScale);
        if (json.iridescenceMap !== undefined) material.iridescenceMap = getTexture(json.iridescenceMap);
        if (json.iridescenceThicknessMap !== undefined) material.iridescenceThicknessMap = getTexture(json.iridescenceThicknessMap);
        if (json.transmissionMap !== undefined) material.transmissionMap = getTexture(json.transmissionMap);
        if (json.thicknessMap !== undefined) material.thicknessMap = getTexture(json.thicknessMap);
        if (json.anisotropyMap !== undefined) material.anisotropyMap = getTexture(json.anisotropyMap);
        if (json.sheenColorMap !== undefined) material.sheenColorMap = getTexture(json.sheenColorMap);
        if (json.sheenRoughnessMap !== undefined) material.sheenRoughnessMap = getTexture(json.sheenRoughnessMap);
        return material;
    }
    setTextures(value) {
        this.textures = value;
        return this;
    }
    createMaterialFromType(type) {
        return $d5b85d29c0b78636$export$3bd6d323353dcf96.createMaterialFromType(type);
    }
    static createMaterialFromType(type) {
        const materialLib = {
            ShadowMaterial: $d5b85d29c0b78636$export$e8564da406055a3,
            SpriteMaterial: $d5b85d29c0b78636$export$5ec7dd1c6994bf8e,
            RawShaderMaterial: $d5b85d29c0b78636$export$21c421a2e1df9d22,
            ShaderMaterial: $d5b85d29c0b78636$export$83c7d75d550a8b0d,
            PointsMaterial: $d5b85d29c0b78636$export$a178c45366ce5d6b,
            MeshPhysicalMaterial: $d5b85d29c0b78636$export$28d04986c4269c9f,
            MeshStandardMaterial: $d5b85d29c0b78636$export$f2980790215acccd,
            MeshPhongMaterial: $d5b85d29c0b78636$export$24c72f71cbaf0678,
            MeshToonMaterial: $d5b85d29c0b78636$export$df893cf97e765622,
            MeshNormalMaterial: $d5b85d29c0b78636$export$bfe8c0a091f41ae7,
            MeshLambertMaterial: $d5b85d29c0b78636$export$5023a9a8114806b8,
            MeshDepthMaterial: $d5b85d29c0b78636$export$2698c22ec13825db,
            MeshDistanceMaterial: $d5b85d29c0b78636$export$33e187ed002f2a19,
            MeshBasicMaterial: $d5b85d29c0b78636$export$55cbcc9b622fe1f5,
            MeshMatcapMaterial: $d5b85d29c0b78636$export$6f5fef6235ec12ee,
            LineDashedMaterial: $d5b85d29c0b78636$export$327886a3efaeaebe,
            LineBasicMaterial: $d5b85d29c0b78636$export$fbaaa33907730a0c,
            Material: $d5b85d29c0b78636$export$a2d8b23205c25948
        };
        return new materialLib[type]();
    }
}
class $d5b85d29c0b78636$export$b5d2dc08d867e41a {
    static decodeText(array) {
        console.warn('THREE.LoaderUtils: decodeText() has been deprecated with r165 and will be removed with r175. Use TextDecoder instead.');
        if (typeof TextDecoder !== 'undefined') return new TextDecoder().decode(array);
        // Avoid the String.fromCharCode.apply(null, array) shortcut, which
        // throws a "maximum call stack size exceeded" error for large arrays.
        let s = '';
        for(let i = 0, il = array.length; i < il; i++)// Implicitly assumes little-endian.
        s += String.fromCharCode(array[i]);
        try {
            // merges multi-byte utf-8 characters.
            return decodeURIComponent(escape(s));
        } catch (e) {
            return s;
        }
    }
    static extractUrlBase(url) {
        const index = url.lastIndexOf('/');
        if (index === -1) return './';
        return url.slice(0, index + 1);
    }
    static resolveURL(url, path) {
        // Invalid URL
        if (typeof url !== 'string' || url === '') return '';
        // Host Relative URL
        if (/^https?:\/\//i.test(path) && /^\//.test(url)) path = path.replace(/(^https?:\/\/[^\/]+).*/i, '$1');
        // Absolute URL http://,https://,//
        if (/^(https?:)?\/\//i.test(url)) return url;
        // Data URI
        if (/^data:.*,.*$/i.test(url)) return url;
        // Blob URL
        if (/^blob:.*$/i.test(url)) return url;
        // Relative URL
        return path + url;
    }
}
class $d5b85d29c0b78636$export$231f009cbe414146 extends $d5b85d29c0b78636$export$b7be63a67df8959 {
    constructor(){
        super();
        this.isInstancedBufferGeometry = true;
        this.type = 'InstancedBufferGeometry';
        this.instanceCount = Infinity;
    }
    copy(source) {
        super.copy(source);
        this.instanceCount = source.instanceCount;
        return this;
    }
    toJSON() {
        const data = super.toJSON();
        data.instanceCount = this.instanceCount;
        data.isInstancedBufferGeometry = true;
        return data;
    }
}
class $d5b85d29c0b78636$export$dc275bb96327833a extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(scope.manager);
        loader.setPath(scope.path);
        loader.setRequestHeader(scope.requestHeader);
        loader.setWithCredentials(scope.withCredentials);
        loader.load(url, function(text) {
            try {
                onLoad(scope.parse(JSON.parse(text)));
            } catch (e) {
                if (onError) onError(e);
                else console.error(e);
                scope.manager.itemError(url);
            }
        }, onProgress, onError);
    }
    parse(json) {
        const interleavedBufferMap = {};
        const arrayBufferMap = {};
        function getInterleavedBuffer(json, uuid) {
            if (interleavedBufferMap[uuid] !== undefined) return interleavedBufferMap[uuid];
            const interleavedBuffers = json.interleavedBuffers;
            const interleavedBuffer = interleavedBuffers[uuid];
            const buffer = getArrayBuffer(json, interleavedBuffer.buffer);
            const array = $d5b85d29c0b78636$var$getTypedArray(interleavedBuffer.type, buffer);
            const ib = new $d5b85d29c0b78636$export$3d5cd879f108f53f(array, interleavedBuffer.stride);
            ib.uuid = interleavedBuffer.uuid;
            interleavedBufferMap[uuid] = ib;
            return ib;
        }
        function getArrayBuffer(json, uuid) {
            if (arrayBufferMap[uuid] !== undefined) return arrayBufferMap[uuid];
            const arrayBuffers = json.arrayBuffers;
            const arrayBuffer = arrayBuffers[uuid];
            const ab = new Uint32Array(arrayBuffer).buffer;
            arrayBufferMap[uuid] = ab;
            return ab;
        }
        const geometry = json.isInstancedBufferGeometry ? new $d5b85d29c0b78636$export$231f009cbe414146() : new $d5b85d29c0b78636$export$b7be63a67df8959();
        const index = json.data.index;
        if (index !== undefined) {
            const typedArray = $d5b85d29c0b78636$var$getTypedArray(index.type, index.array);
            geometry.setIndex(new $d5b85d29c0b78636$export$8dea267bd6bde117(typedArray, 1));
        }
        const attributes = json.data.attributes;
        for(const key in attributes){
            const attribute = attributes[key];
            let bufferAttribute;
            if (attribute.isInterleavedBufferAttribute) {
                const interleavedBuffer = getInterleavedBuffer(json.data, attribute.data);
                bufferAttribute = new $d5b85d29c0b78636$export$920b6d07334599c7(interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized);
            } else {
                const typedArray = $d5b85d29c0b78636$var$getTypedArray(attribute.type, attribute.array);
                const bufferAttributeConstr = attribute.isInstancedBufferAttribute ? $d5b85d29c0b78636$export$32ea87a8b54d744a : $d5b85d29c0b78636$export$8dea267bd6bde117;
                bufferAttribute = new bufferAttributeConstr(typedArray, attribute.itemSize, attribute.normalized);
            }
            if (attribute.name !== undefined) bufferAttribute.name = attribute.name;
            if (attribute.usage !== undefined) bufferAttribute.setUsage(attribute.usage);
            geometry.setAttribute(key, bufferAttribute);
        }
        const morphAttributes = json.data.morphAttributes;
        if (morphAttributes) for(const key in morphAttributes){
            const attributeArray = morphAttributes[key];
            const array = [];
            for(let i = 0, il = attributeArray.length; i < il; i++){
                const attribute = attributeArray[i];
                let bufferAttribute;
                if (attribute.isInterleavedBufferAttribute) {
                    const interleavedBuffer = getInterleavedBuffer(json.data, attribute.data);
                    bufferAttribute = new $d5b85d29c0b78636$export$920b6d07334599c7(interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized);
                } else {
                    const typedArray = $d5b85d29c0b78636$var$getTypedArray(attribute.type, attribute.array);
                    bufferAttribute = new $d5b85d29c0b78636$export$8dea267bd6bde117(typedArray, attribute.itemSize, attribute.normalized);
                }
                if (attribute.name !== undefined) bufferAttribute.name = attribute.name;
                array.push(bufferAttribute);
            }
            geometry.morphAttributes[key] = array;
        }
        const morphTargetsRelative = json.data.morphTargetsRelative;
        if (morphTargetsRelative) geometry.morphTargetsRelative = true;
        const groups = json.data.groups || json.data.drawcalls || json.data.offsets;
        if (groups !== undefined) for(let i = 0, n = groups.length; i !== n; ++i){
            const group = groups[i];
            geometry.addGroup(group.start, group.count, group.materialIndex);
        }
        const boundingSphere = json.data.boundingSphere;
        if (boundingSphere !== undefined) {
            const center = new $d5b85d29c0b78636$export$64b5c384219d3699();
            if (boundingSphere.center !== undefined) center.fromArray(boundingSphere.center);
            geometry.boundingSphere = new $d5b85d29c0b78636$export$805e8b72413ccaba(center, boundingSphere.radius);
        }
        if (json.name) geometry.name = json.name;
        if (json.userData) geometry.userData = json.userData;
        return geometry;
    }
}
class $d5b85d29c0b78636$export$40110c8505c5ad19 extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const path = this.path === '' ? $d5b85d29c0b78636$export$b5d2dc08d867e41a.extractUrlBase(url) : this.path;
        this.resourcePath = this.resourcePath || path;
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(this.manager);
        loader.setPath(this.path);
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(this.withCredentials);
        loader.load(url, function(text) {
            let json = null;
            try {
                json = JSON.parse(text);
            } catch (error) {
                if (onError !== undefined) onError(error);
                console.error('THREE:ObjectLoader: Can\'t parse ' + url + '.', error.message);
                return;
            }
            const metadata = json.metadata;
            if (metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry') {
                if (onError !== undefined) onError(new Error('THREE.ObjectLoader: Can\'t load ' + url));
                console.error('THREE.ObjectLoader: Can\'t load ' + url);
                return;
            }
            scope.parse(json, onLoad);
        }, onProgress, onError);
    }
    async loadAsync(url, onProgress) {
        const scope = this;
        const path = this.path === '' ? $d5b85d29c0b78636$export$b5d2dc08d867e41a.extractUrlBase(url) : this.path;
        this.resourcePath = this.resourcePath || path;
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(this.manager);
        loader.setPath(this.path);
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(this.withCredentials);
        const text = await loader.loadAsync(url, onProgress);
        const json = JSON.parse(text);
        const metadata = json.metadata;
        if (metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry') throw new Error('THREE.ObjectLoader: Can\'t load ' + url);
        return await scope.parseAsync(json);
    }
    parse(json, onLoad) {
        const animations = this.parseAnimations(json.animations);
        const shapes = this.parseShapes(json.shapes);
        const geometries = this.parseGeometries(json.geometries, shapes);
        const images = this.parseImages(json.images, function() {
            if (onLoad !== undefined) onLoad(object);
        });
        const textures = this.parseTextures(json.textures, images);
        const materials = this.parseMaterials(json.materials, textures);
        const object = this.parseObject(json.object, geometries, materials, textures, animations);
        const skeletons = this.parseSkeletons(json.skeletons, object);
        this.bindSkeletons(object, skeletons);
        this.bindLightTargets(object);
        //
        if (onLoad !== undefined) {
            let hasImages = false;
            for(const uuid in images)if (images[uuid].data instanceof HTMLImageElement) {
                hasImages = true;
                break;
            }
            if (hasImages === false) onLoad(object);
        }
        return object;
    }
    async parseAsync(json) {
        const animations = this.parseAnimations(json.animations);
        const shapes = this.parseShapes(json.shapes);
        const geometries = this.parseGeometries(json.geometries, shapes);
        const images = await this.parseImagesAsync(json.images);
        const textures = this.parseTextures(json.textures, images);
        const materials = this.parseMaterials(json.materials, textures);
        const object = this.parseObject(json.object, geometries, materials, textures, animations);
        const skeletons = this.parseSkeletons(json.skeletons, object);
        this.bindSkeletons(object, skeletons);
        this.bindLightTargets(object);
        return object;
    }
    parseShapes(json) {
        const shapes = {};
        if (json !== undefined) for(let i = 0, l = json.length; i < l; i++){
            const shape = new $d5b85d29c0b78636$export$6428a7f2611ef1fa().fromJSON(json[i]);
            shapes[shape.uuid] = shape;
        }
        return shapes;
    }
    parseSkeletons(json, object) {
        const skeletons = {};
        const bones = {};
        // generate bone lookup table
        object.traverse(function(child) {
            if (child.isBone) bones[child.uuid] = child;
        });
        // create skeletons
        if (json !== undefined) for(let i = 0, l = json.length; i < l; i++){
            const skeleton = new $d5b85d29c0b78636$export$8f31e4c4a37b8e9c().fromJSON(json[i], bones);
            skeletons[skeleton.uuid] = skeleton;
        }
        return skeletons;
    }
    parseGeometries(json, shapes) {
        const geometries = {};
        if (json !== undefined) {
            const bufferGeometryLoader = new $d5b85d29c0b78636$export$dc275bb96327833a();
            for(let i = 0, l = json.length; i < l; i++){
                let geometry;
                const data = json[i];
                switch(data.type){
                    case 'BufferGeometry':
                    case 'InstancedBufferGeometry':
                        geometry = bufferGeometryLoader.parse(data);
                        break;
                    default:
                        if (data.type in $d5b85d29c0b78636$var$Geometries) geometry = $d5b85d29c0b78636$var$Geometries[data.type].fromJSON(data, shapes);
                        else console.warn(`THREE.ObjectLoader: Unsupported geometry type "${data.type}"`);
                }
                geometry.uuid = data.uuid;
                if (data.name !== undefined) geometry.name = data.name;
                if (data.userData !== undefined) geometry.userData = data.userData;
                geometries[data.uuid] = geometry;
            }
        }
        return geometries;
    }
    parseMaterials(json, textures) {
        const cache = {}; // MultiMaterial
        const materials = {};
        if (json !== undefined) {
            const loader = new $d5b85d29c0b78636$export$3bd6d323353dcf96();
            loader.setTextures(textures);
            for(let i = 0, l = json.length; i < l; i++){
                const data = json[i];
                if (cache[data.uuid] === undefined) cache[data.uuid] = loader.parse(data);
                materials[data.uuid] = cache[data.uuid];
            }
        }
        return materials;
    }
    parseAnimations(json) {
        const animations = {};
        if (json !== undefined) for(let i = 0; i < json.length; i++){
            const data = json[i];
            const clip = $d5b85d29c0b78636$export$d942c706bf23829c.parse(data);
            animations[clip.uuid] = clip;
        }
        return animations;
    }
    parseImages(json, onLoad) {
        const scope = this;
        const images = {};
        let loader;
        function loadImage(url) {
            scope.manager.itemStart(url);
            return loader.load(url, function() {
                scope.manager.itemEnd(url);
            }, undefined, function() {
                scope.manager.itemError(url);
                scope.manager.itemEnd(url);
            });
        }
        function deserializeImage(image) {
            if (typeof image === 'string') {
                const url = image;
                const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test(url) ? url : scope.resourcePath + url;
                return loadImage(path);
            } else {
                if (image.data) return {
                    data: $d5b85d29c0b78636$var$getTypedArray(image.type, image.data),
                    width: image.width,
                    height: image.height
                };
                else return null;
            }
        }
        if (json !== undefined && json.length > 0) {
            const manager = new $d5b85d29c0b78636$export$99cc795e99919eed(onLoad);
            loader = new $d5b85d29c0b78636$export$8905ce1c7a2464a1(manager);
            loader.setCrossOrigin(this.crossOrigin);
            for(let i = 0, il = json.length; i < il; i++){
                const image = json[i];
                const url = image.url;
                if (Array.isArray(url)) {
                    // load array of images e.g CubeTexture
                    const imageArray = [];
                    for(let j = 0, jl = url.length; j < jl; j++){
                        const currentUrl = url[j];
                        const deserializedImage = deserializeImage(currentUrl);
                        if (deserializedImage !== null) {
                            if (deserializedImage instanceof HTMLImageElement) imageArray.push(deserializedImage);
                            else // special case: handle array of data textures for cube textures
                            imageArray.push(new $d5b85d29c0b78636$export$b691f601014eabe1(deserializedImage.data, deserializedImage.width, deserializedImage.height));
                        }
                    }
                    images[image.uuid] = new $d5b85d29c0b78636$export$1d2df86270c81ecb(imageArray);
                } else {
                    // load single image
                    const deserializedImage = deserializeImage(image.url);
                    images[image.uuid] = new $d5b85d29c0b78636$export$1d2df86270c81ecb(deserializedImage);
                }
            }
        }
        return images;
    }
    async parseImagesAsync(json) {
        const scope = this;
        const images = {};
        let loader;
        async function deserializeImage(image) {
            if (typeof image === 'string') {
                const url = image;
                const path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test(url) ? url : scope.resourcePath + url;
                return await loader.loadAsync(path);
            } else {
                if (image.data) return {
                    data: $d5b85d29c0b78636$var$getTypedArray(image.type, image.data),
                    width: image.width,
                    height: image.height
                };
                else return null;
            }
        }
        if (json !== undefined && json.length > 0) {
            loader = new $d5b85d29c0b78636$export$8905ce1c7a2464a1(this.manager);
            loader.setCrossOrigin(this.crossOrigin);
            for(let i = 0, il = json.length; i < il; i++){
                const image = json[i];
                const url = image.url;
                if (Array.isArray(url)) {
                    // load array of images e.g CubeTexture
                    const imageArray = [];
                    for(let j = 0, jl = url.length; j < jl; j++){
                        const currentUrl = url[j];
                        const deserializedImage = await deserializeImage(currentUrl);
                        if (deserializedImage !== null) {
                            if (deserializedImage instanceof HTMLImageElement) imageArray.push(deserializedImage);
                            else // special case: handle array of data textures for cube textures
                            imageArray.push(new $d5b85d29c0b78636$export$b691f601014eabe1(deserializedImage.data, deserializedImage.width, deserializedImage.height));
                        }
                    }
                    images[image.uuid] = new $d5b85d29c0b78636$export$1d2df86270c81ecb(imageArray);
                } else {
                    // load single image
                    const deserializedImage = await deserializeImage(image.url);
                    images[image.uuid] = new $d5b85d29c0b78636$export$1d2df86270c81ecb(deserializedImage);
                }
            }
        }
        return images;
    }
    parseTextures(json, images) {
        function parseConstant(value, type) {
            if (typeof value === 'number') return value;
            console.warn('THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value);
            return type[value];
        }
        const textures = {};
        if (json !== undefined) for(let i = 0, l = json.length; i < l; i++){
            const data = json[i];
            if (data.image === undefined) console.warn('THREE.ObjectLoader: No "image" specified for', data.uuid);
            if (images[data.image] === undefined) console.warn('THREE.ObjectLoader: Undefined image', data.image);
            const source = images[data.image];
            const image = source.data;
            let texture;
            if (Array.isArray(image)) {
                texture = new $d5b85d29c0b78636$export$ee2e5a18258a4049();
                if (image.length === 6) texture.needsUpdate = true;
            } else {
                if (image && image.data) texture = new $d5b85d29c0b78636$export$b691f601014eabe1();
                else texture = new $d5b85d29c0b78636$export$5431306cf43de24a();
                if (image) texture.needsUpdate = true; // textures can have undefined image data
            }
            texture.source = source;
            texture.uuid = data.uuid;
            if (data.name !== undefined) texture.name = data.name;
            if (data.mapping !== undefined) texture.mapping = parseConstant(data.mapping, $d5b85d29c0b78636$var$TEXTURE_MAPPING);
            if (data.channel !== undefined) texture.channel = data.channel;
            if (data.offset !== undefined) texture.offset.fromArray(data.offset);
            if (data.repeat !== undefined) texture.repeat.fromArray(data.repeat);
            if (data.center !== undefined) texture.center.fromArray(data.center);
            if (data.rotation !== undefined) texture.rotation = data.rotation;
            if (data.wrap !== undefined) {
                texture.wrapS = parseConstant(data.wrap[0], $d5b85d29c0b78636$var$TEXTURE_WRAPPING);
                texture.wrapT = parseConstant(data.wrap[1], $d5b85d29c0b78636$var$TEXTURE_WRAPPING);
            }
            if (data.format !== undefined) texture.format = data.format;
            if (data.internalFormat !== undefined) texture.internalFormat = data.internalFormat;
            if (data.type !== undefined) texture.type = data.type;
            if (data.colorSpace !== undefined) texture.colorSpace = data.colorSpace;
            if (data.minFilter !== undefined) texture.minFilter = parseConstant(data.minFilter, $d5b85d29c0b78636$var$TEXTURE_FILTER);
            if (data.magFilter !== undefined) texture.magFilter = parseConstant(data.magFilter, $d5b85d29c0b78636$var$TEXTURE_FILTER);
            if (data.anisotropy !== undefined) texture.anisotropy = data.anisotropy;
            if (data.flipY !== undefined) texture.flipY = data.flipY;
            if (data.generateMipmaps !== undefined) texture.generateMipmaps = data.generateMipmaps;
            if (data.premultiplyAlpha !== undefined) texture.premultiplyAlpha = data.premultiplyAlpha;
            if (data.unpackAlignment !== undefined) texture.unpackAlignment = data.unpackAlignment;
            if (data.compareFunction !== undefined) texture.compareFunction = data.compareFunction;
            if (data.userData !== undefined) texture.userData = data.userData;
            textures[data.uuid] = texture;
        }
        return textures;
    }
    parseObject(data, geometries, materials, textures, animations) {
        let object;
        function getGeometry(name) {
            if (geometries[name] === undefined) console.warn('THREE.ObjectLoader: Undefined geometry', name);
            return geometries[name];
        }
        function getMaterial(name) {
            if (name === undefined) return undefined;
            if (Array.isArray(name)) {
                const array = [];
                for(let i = 0, l = name.length; i < l; i++){
                    const uuid = name[i];
                    if (materials[uuid] === undefined) console.warn('THREE.ObjectLoader: Undefined material', uuid);
                    array.push(materials[uuid]);
                }
                return array;
            }
            if (materials[name] === undefined) console.warn('THREE.ObjectLoader: Undefined material', name);
            return materials[name];
        }
        function getTexture(uuid) {
            if (textures[uuid] === undefined) console.warn('THREE.ObjectLoader: Undefined texture', uuid);
            return textures[uuid];
        }
        let geometry, material;
        switch(data.type){
            case 'Scene':
                object = new $d5b85d29c0b78636$export$38af1803e3442a7f();
                if (data.background !== undefined) {
                    if (Number.isInteger(data.background)) object.background = new $d5b85d29c0b78636$export$892596cec99bc70e(data.background);
                    else object.background = getTexture(data.background);
                }
                if (data.environment !== undefined) object.environment = getTexture(data.environment);
                if (data.fog !== undefined) {
                    if (data.fog.type === 'Fog') object.fog = new $d5b85d29c0b78636$export$3c890837b09508d4(data.fog.color, data.fog.near, data.fog.far);
                    else if (data.fog.type === 'FogExp2') object.fog = new $d5b85d29c0b78636$export$6f1519f023b8d0f6(data.fog.color, data.fog.density);
                    if (data.fog.name !== '') object.fog.name = data.fog.name;
                }
                if (data.backgroundBlurriness !== undefined) object.backgroundBlurriness = data.backgroundBlurriness;
                if (data.backgroundIntensity !== undefined) object.backgroundIntensity = data.backgroundIntensity;
                if (data.backgroundRotation !== undefined) object.backgroundRotation.fromArray(data.backgroundRotation);
                if (data.environmentIntensity !== undefined) object.environmentIntensity = data.environmentIntensity;
                if (data.environmentRotation !== undefined) object.environmentRotation.fromArray(data.environmentRotation);
                break;
            case 'PerspectiveCamera':
                object = new $d5b85d29c0b78636$export$74e4ae24825f68d7(data.fov, data.aspect, data.near, data.far);
                if (data.focus !== undefined) object.focus = data.focus;
                if (data.zoom !== undefined) object.zoom = data.zoom;
                if (data.filmGauge !== undefined) object.filmGauge = data.filmGauge;
                if (data.filmOffset !== undefined) object.filmOffset = data.filmOffset;
                if (data.view !== undefined) object.view = Object.assign({}, data.view);
                break;
            case 'OrthographicCamera':
                object = new $d5b85d29c0b78636$export$9ebf355ee4ed261b(data.left, data.right, data.top, data.bottom, data.near, data.far);
                if (data.zoom !== undefined) object.zoom = data.zoom;
                if (data.view !== undefined) object.view = Object.assign({}, data.view);
                break;
            case 'AmbientLight':
                object = new $d5b85d29c0b78636$export$af279bfef9ec2c96(data.color, data.intensity);
                break;
            case 'DirectionalLight':
                object = new $d5b85d29c0b78636$export$3fea33cc9972c868(data.color, data.intensity);
                object.target = data.target || '';
                break;
            case 'PointLight':
                object = new $d5b85d29c0b78636$export$4c9c1cb3f0b6f455(data.color, data.intensity, data.distance, data.decay);
                break;
            case 'RectAreaLight':
                object = new $d5b85d29c0b78636$export$61db2d908bbd2429(data.color, data.intensity, data.width, data.height);
                break;
            case 'SpotLight':
                object = new $d5b85d29c0b78636$export$81495cbb73897362(data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay);
                object.target = data.target || '';
                break;
            case 'HemisphereLight':
                object = new $d5b85d29c0b78636$export$8d474f55edbb9624(data.color, data.groundColor, data.intensity);
                break;
            case 'LightProbe':
                object = new $d5b85d29c0b78636$export$e7ef036e309b38d2().fromJSON(data);
                break;
            case 'SkinnedMesh':
                geometry = getGeometry(data.geometry);
                material = getMaterial(data.material);
                object = new $d5b85d29c0b78636$export$b303577035157ecf(geometry, material);
                if (data.bindMode !== undefined) object.bindMode = data.bindMode;
                if (data.bindMatrix !== undefined) object.bindMatrix.fromArray(data.bindMatrix);
                if (data.skeleton !== undefined) object.skeleton = data.skeleton;
                break;
            case 'Mesh':
                geometry = getGeometry(data.geometry);
                material = getMaterial(data.material);
                object = new $d5b85d29c0b78636$export$e176487c05830cc5(geometry, material);
                break;
            case 'InstancedMesh':
                geometry = getGeometry(data.geometry);
                material = getMaterial(data.material);
                const count = data.count;
                const instanceMatrix = data.instanceMatrix;
                const instanceColor = data.instanceColor;
                object = new $d5b85d29c0b78636$export$f3c979c331175ad7(geometry, material, count);
                object.instanceMatrix = new $d5b85d29c0b78636$export$32ea87a8b54d744a(new Float32Array(instanceMatrix.array), 16);
                if (instanceColor !== undefined) object.instanceColor = new $d5b85d29c0b78636$export$32ea87a8b54d744a(new Float32Array(instanceColor.array), instanceColor.itemSize);
                break;
            case 'BatchedMesh':
                geometry = getGeometry(data.geometry);
                material = getMaterial(data.material);
                object = new $d5b85d29c0b78636$export$6e01c5ee52ed8f7b(data.maxInstanceCount, data.maxVertexCount, data.maxIndexCount, material);
                object.geometry = geometry;
                object.perObjectFrustumCulled = data.perObjectFrustumCulled;
                object.sortObjects = data.sortObjects;
                object._drawRanges = data.drawRanges;
                object._reservedRanges = data.reservedRanges;
                object._visibility = data.visibility;
                object._active = data.active;
                object._bounds = data.bounds.map((bound)=>{
                    const box = new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
                    box.min.fromArray(bound.boxMin);
                    box.max.fromArray(bound.boxMax);
                    const sphere = new $d5b85d29c0b78636$export$805e8b72413ccaba();
                    sphere.radius = bound.sphereRadius;
                    sphere.center.fromArray(bound.sphereCenter);
                    return {
                        boxInitialized: bound.boxInitialized,
                        box: box,
                        sphereInitialized: bound.sphereInitialized,
                        sphere: sphere
                    };
                });
                object._maxInstanceCount = data.maxInstanceCount;
                object._maxVertexCount = data.maxVertexCount;
                object._maxIndexCount = data.maxIndexCount;
                object._geometryInitialized = data.geometryInitialized;
                object._geometryCount = data.geometryCount;
                object._matricesTexture = getTexture(data.matricesTexture.uuid);
                if (data.colorsTexture !== undefined) object._colorsTexture = getTexture(data.colorsTexture.uuid);
                break;
            case 'LOD':
                object = new $d5b85d29c0b78636$export$112e7237be0c5f30();
                break;
            case 'Line':
                object = new $d5b85d29c0b78636$export$17d680238e50603e(getGeometry(data.geometry), getMaterial(data.material));
                break;
            case 'LineLoop':
                object = new $d5b85d29c0b78636$export$f85a24d745e4f17d(getGeometry(data.geometry), getMaterial(data.material));
                break;
            case 'LineSegments':
                object = new $d5b85d29c0b78636$export$ff1ed10fedfdd604(getGeometry(data.geometry), getMaterial(data.material));
                break;
            case 'PointCloud':
            case 'Points':
                object = new $d5b85d29c0b78636$export$1c787534cb11aa3e(getGeometry(data.geometry), getMaterial(data.material));
                break;
            case 'Sprite':
                object = new $d5b85d29c0b78636$export$3075603db8e6204c(getMaterial(data.material));
                break;
            case 'Group':
                object = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
                break;
            case 'Bone':
                object = new $d5b85d29c0b78636$export$b127726e56765aa4();
                break;
            default:
                object = new $d5b85d29c0b78636$export$e4dd07dff30cc924();
        }
        object.uuid = data.uuid;
        if (data.name !== undefined) object.name = data.name;
        if (data.matrix !== undefined) {
            object.matrix.fromArray(data.matrix);
            if (data.matrixAutoUpdate !== undefined) object.matrixAutoUpdate = data.matrixAutoUpdate;
            if (object.matrixAutoUpdate) object.matrix.decompose(object.position, object.quaternion, object.scale);
        } else {
            if (data.position !== undefined) object.position.fromArray(data.position);
            if (data.rotation !== undefined) object.rotation.fromArray(data.rotation);
            if (data.quaternion !== undefined) object.quaternion.fromArray(data.quaternion);
            if (data.scale !== undefined) object.scale.fromArray(data.scale);
        }
        if (data.up !== undefined) object.up.fromArray(data.up);
        if (data.castShadow !== undefined) object.castShadow = data.castShadow;
        if (data.receiveShadow !== undefined) object.receiveShadow = data.receiveShadow;
        if (data.shadow) {
            if (data.shadow.intensity !== undefined) object.shadow.intensity = data.shadow.intensity;
            if (data.shadow.bias !== undefined) object.shadow.bias = data.shadow.bias;
            if (data.shadow.normalBias !== undefined) object.shadow.normalBias = data.shadow.normalBias;
            if (data.shadow.radius !== undefined) object.shadow.radius = data.shadow.radius;
            if (data.shadow.mapSize !== undefined) object.shadow.mapSize.fromArray(data.shadow.mapSize);
            if (data.shadow.camera !== undefined) object.shadow.camera = this.parseObject(data.shadow.camera);
        }
        if (data.visible !== undefined) object.visible = data.visible;
        if (data.frustumCulled !== undefined) object.frustumCulled = data.frustumCulled;
        if (data.renderOrder !== undefined) object.renderOrder = data.renderOrder;
        if (data.userData !== undefined) object.userData = data.userData;
        if (data.layers !== undefined) object.layers.mask = data.layers;
        if (data.children !== undefined) {
            const children = data.children;
            for(let i = 0; i < children.length; i++)object.add(this.parseObject(children[i], geometries, materials, textures, animations));
        }
        if (data.animations !== undefined) {
            const objectAnimations = data.animations;
            for(let i = 0; i < objectAnimations.length; i++){
                const uuid = objectAnimations[i];
                object.animations.push(animations[uuid]);
            }
        }
        if (data.type === 'LOD') {
            if (data.autoUpdate !== undefined) object.autoUpdate = data.autoUpdate;
            const levels = data.levels;
            for(let l = 0; l < levels.length; l++){
                const level = levels[l];
                const child = object.getObjectByProperty('uuid', level.object);
                if (child !== undefined) object.addLevel(child, level.distance, level.hysteresis);
            }
        }
        return object;
    }
    bindSkeletons(object, skeletons) {
        if (Object.keys(skeletons).length === 0) return;
        object.traverse(function(child) {
            if (child.isSkinnedMesh === true && child.skeleton !== undefined) {
                const skeleton = skeletons[child.skeleton];
                if (skeleton === undefined) console.warn('THREE.ObjectLoader: No skeleton found with UUID:', child.skeleton);
                else child.bind(skeleton, child.bindMatrix);
            }
        });
    }
    bindLightTargets(object) {
        object.traverse(function(child) {
            if (child.isDirectionalLight || child.isSpotLight) {
                const uuid = child.target;
                const target = object.getObjectByProperty('uuid', uuid);
                if (target !== undefined) child.target = target;
                else child.target = new $d5b85d29c0b78636$export$e4dd07dff30cc924();
            }
        });
    }
}
const $d5b85d29c0b78636$var$TEXTURE_MAPPING = {
    UVMapping: $d5b85d29c0b78636$export$1beec6768cbb3d2d,
    CubeReflectionMapping: $d5b85d29c0b78636$export$8759762a6477f2c4,
    CubeRefractionMapping: $d5b85d29c0b78636$export$dc59f8aed047f61d,
    EquirectangularReflectionMapping: $d5b85d29c0b78636$export$d64030b316d3b087,
    EquirectangularRefractionMapping: $d5b85d29c0b78636$export$ee99d97d46898098,
    CubeUVReflectionMapping: $d5b85d29c0b78636$export$dbf3e70ff37af79
};
const $d5b85d29c0b78636$var$TEXTURE_WRAPPING = {
    RepeatWrapping: $d5b85d29c0b78636$export$533346c8e8dac0f5,
    ClampToEdgeWrapping: $d5b85d29c0b78636$export$9d9334239a5a5e06,
    MirroredRepeatWrapping: $d5b85d29c0b78636$export$c7e7c00b14f51a4f
};
const $d5b85d29c0b78636$var$TEXTURE_FILTER = {
    NearestFilter: $d5b85d29c0b78636$export$727aa5ec3fe39bf0,
    NearestMipmapNearestFilter: $d5b85d29c0b78636$export$d129e38cf6feaa8c,
    NearestMipmapLinearFilter: $d5b85d29c0b78636$export$d2327c1afe5bfdf2,
    LinearFilter: $d5b85d29c0b78636$export$8a72f490b25c56c8,
    LinearMipmapNearestFilter: $d5b85d29c0b78636$export$19a719f377145a13,
    LinearMipmapLinearFilter: $d5b85d29c0b78636$export$5d8599b6a933fb1b
};
class $d5b85d29c0b78636$export$52286b55c4a9b51f extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
        this.isImageBitmapLoader = true;
        if (typeof createImageBitmap === 'undefined') console.warn('THREE.ImageBitmapLoader: createImageBitmap() not supported.');
        if (typeof fetch === 'undefined') console.warn('THREE.ImageBitmapLoader: fetch() not supported.');
        this.options = {
            premultiplyAlpha: 'none'
        };
    }
    setOptions(options) {
        this.options = options;
        return this;
    }
    load(url, onLoad, onProgress, onError) {
        if (url === undefined) url = '';
        if (this.path !== undefined) url = this.path + url;
        url = this.manager.resolveURL(url);
        const scope = this;
        const cached = $d5b85d29c0b78636$export$94affb487e701bf2.get(url);
        if (cached !== undefined) {
            scope.manager.itemStart(url);
            // If cached is a promise, wait for it to resolve
            if (cached.then) {
                cached.then((imageBitmap)=>{
                    if (onLoad) onLoad(imageBitmap);
                    scope.manager.itemEnd(url);
                }).catch((e)=>{
                    if (onError) onError(e);
                });
                return;
            }
            // If cached is not a promise (i.e., it's already an imageBitmap)
            setTimeout(function() {
                if (onLoad) onLoad(cached);
                scope.manager.itemEnd(url);
            }, 0);
            return cached;
        }
        const fetchOptions = {};
        fetchOptions.credentials = this.crossOrigin === 'anonymous' ? 'same-origin' : 'include';
        fetchOptions.headers = this.requestHeader;
        const promise = fetch(url, fetchOptions).then(function(res) {
            return res.blob();
        }).then(function(blob) {
            return createImageBitmap(blob, Object.assign(scope.options, {
                colorSpaceConversion: 'none'
            }));
        }).then(function(imageBitmap) {
            $d5b85d29c0b78636$export$94affb487e701bf2.add(url, imageBitmap);
            if (onLoad) onLoad(imageBitmap);
            scope.manager.itemEnd(url);
            return imageBitmap;
        }).catch(function(e) {
            if (onError) onError(e);
            $d5b85d29c0b78636$export$94affb487e701bf2.remove(url);
            scope.manager.itemError(url);
            scope.manager.itemEnd(url);
        });
        $d5b85d29c0b78636$export$94affb487e701bf2.add(url, promise);
        scope.manager.itemStart(url);
    }
}
let $d5b85d29c0b78636$var$_context;
class $d5b85d29c0b78636$export$fcbc63750ec2a81f {
    static getContext() {
        if ($d5b85d29c0b78636$var$_context === undefined) $d5b85d29c0b78636$var$_context = new (window.AudioContext || window.webkitAudioContext)();
        return $d5b85d29c0b78636$var$_context;
    }
    static setContext(value) {
        $d5b85d29c0b78636$var$_context = value;
    }
}
class $d5b85d29c0b78636$export$d8d5fccfbf47714e extends $d5b85d29c0b78636$export$3b0d6d7590275603 {
    constructor(manager){
        super(manager);
    }
    load(url, onLoad, onProgress, onError) {
        const scope = this;
        const loader = new $d5b85d29c0b78636$export$98435a25b5cf7b2b(this.manager);
        loader.setResponseType('arraybuffer');
        loader.setPath(this.path);
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(this.withCredentials);
        loader.load(url, function(buffer) {
            try {
                // Create a copy of the buffer. The `decodeAudioData` method
                // detaches the buffer when complete, preventing reuse.
                const bufferCopy = buffer.slice(0);
                const context = $d5b85d29c0b78636$export$fcbc63750ec2a81f.getContext();
                context.decodeAudioData(bufferCopy, function(audioBuffer) {
                    onLoad(audioBuffer);
                }).catch(handleError);
            } catch (e) {
                handleError(e);
            }
        }, onProgress, onError);
        function handleError(e) {
            if (onError) onError(e);
            else console.error(e);
            scope.manager.itemError(url);
        }
    }
}
const $d5b85d29c0b78636$var$_eyeRight = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_eyeLeft = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_projectionMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
class $d5b85d29c0b78636$export$bc7f73a1065bee0c {
    constructor(){
        this.type = 'StereoCamera';
        this.aspect = 1;
        this.eyeSep = 0.064;
        this.cameraL = new $d5b85d29c0b78636$export$74e4ae24825f68d7();
        this.cameraL.layers.enable(1);
        this.cameraL.matrixAutoUpdate = false;
        this.cameraR = new $d5b85d29c0b78636$export$74e4ae24825f68d7();
        this.cameraR.layers.enable(2);
        this.cameraR.matrixAutoUpdate = false;
        this._cache = {
            focus: null,
            fov: null,
            aspect: null,
            near: null,
            far: null,
            zoom: null,
            eyeSep: null
        };
    }
    update(camera) {
        const cache = this._cache;
        const needsUpdate = cache.focus !== camera.focus || cache.fov !== camera.fov || cache.aspect !== camera.aspect * this.aspect || cache.near !== camera.near || cache.far !== camera.far || cache.zoom !== camera.zoom || cache.eyeSep !== this.eyeSep;
        if (needsUpdate) {
            cache.focus = camera.focus;
            cache.fov = camera.fov;
            cache.aspect = camera.aspect * this.aspect;
            cache.near = camera.near;
            cache.far = camera.far;
            cache.zoom = camera.zoom;
            cache.eyeSep = this.eyeSep;
            // Off-axis stereoscopic effect based on
            // http://paulbourke.net/stereographics/stereorender/
            $d5b85d29c0b78636$var$_projectionMatrix.copy(camera.projectionMatrix);
            const eyeSepHalf = cache.eyeSep / 2;
            const eyeSepOnProjection = eyeSepHalf * cache.near / cache.focus;
            const ymax = cache.near * Math.tan($d5b85d29c0b78636$var$DEG2RAD * cache.fov * 0.5) / cache.zoom;
            let xmin, xmax;
            // translate xOffset
            $d5b85d29c0b78636$var$_eyeLeft.elements[12] = -eyeSepHalf;
            $d5b85d29c0b78636$var$_eyeRight.elements[12] = eyeSepHalf;
            // for left eye
            xmin = -ymax * cache.aspect + eyeSepOnProjection;
            xmax = ymax * cache.aspect + eyeSepOnProjection;
            $d5b85d29c0b78636$var$_projectionMatrix.elements[0] = 2 * cache.near / (xmax - xmin);
            $d5b85d29c0b78636$var$_projectionMatrix.elements[8] = (xmax + xmin) / (xmax - xmin);
            this.cameraL.projectionMatrix.copy($d5b85d29c0b78636$var$_projectionMatrix);
            // for right eye
            xmin = -ymax * cache.aspect - eyeSepOnProjection;
            xmax = ymax * cache.aspect - eyeSepOnProjection;
            $d5b85d29c0b78636$var$_projectionMatrix.elements[0] = 2 * cache.near / (xmax - xmin);
            $d5b85d29c0b78636$var$_projectionMatrix.elements[8] = (xmax + xmin) / (xmax - xmin);
            this.cameraR.projectionMatrix.copy($d5b85d29c0b78636$var$_projectionMatrix);
        }
        this.cameraL.matrixWorld.copy(camera.matrixWorld).multiply($d5b85d29c0b78636$var$_eyeLeft);
        this.cameraR.matrixWorld.copy(camera.matrixWorld).multiply($d5b85d29c0b78636$var$_eyeRight);
    }
}
class $d5b85d29c0b78636$export$56b937d9e5581166 extends $d5b85d29c0b78636$export$74e4ae24825f68d7 {
    constructor(array = []){
        super();
        this.isArrayCamera = true;
        this.cameras = array;
    }
}
class $d5b85d29c0b78636$export$9735c82c4bae3302 {
    constructor(autoStart = true){
        this.autoStart = autoStart;
        this.startTime = 0;
        this.oldTime = 0;
        this.elapsedTime = 0;
        this.running = false;
    }
    start() {
        this.startTime = $d5b85d29c0b78636$var$now();
        this.oldTime = this.startTime;
        this.elapsedTime = 0;
        this.running = true;
    }
    stop() {
        this.getElapsedTime();
        this.running = false;
        this.autoStart = false;
    }
    getElapsedTime() {
        this.getDelta();
        return this.elapsedTime;
    }
    getDelta() {
        let diff = 0;
        if (this.autoStart && !this.running) {
            this.start();
            return 0;
        }
        if (this.running) {
            const newTime = $d5b85d29c0b78636$var$now();
            diff = (newTime - this.oldTime) / 1000;
            this.oldTime = newTime;
            this.elapsedTime += diff;
        }
        return diff;
    }
}
function $d5b85d29c0b78636$var$now() {
    return performance.now();
}
const $d5b85d29c0b78636$var$_position$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_quaternion$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
const $d5b85d29c0b78636$var$_scale$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_orientation$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$8a1b810c6fde8951 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(){
        super();
        this.type = 'AudioListener';
        this.context = $d5b85d29c0b78636$export$fcbc63750ec2a81f.getContext();
        this.gain = this.context.createGain();
        this.gain.connect(this.context.destination);
        this.filter = null;
        this.timeDelta = 0;
        // private
        this._clock = new $d5b85d29c0b78636$export$9735c82c4bae3302();
    }
    getInput() {
        return this.gain;
    }
    removeFilter() {
        if (this.filter !== null) {
            this.gain.disconnect(this.filter);
            this.filter.disconnect(this.context.destination);
            this.gain.connect(this.context.destination);
            this.filter = null;
        }
        return this;
    }
    getFilter() {
        return this.filter;
    }
    setFilter(value) {
        if (this.filter !== null) {
            this.gain.disconnect(this.filter);
            this.filter.disconnect(this.context.destination);
        } else this.gain.disconnect(this.context.destination);
        this.filter = value;
        this.gain.connect(this.filter);
        this.filter.connect(this.context.destination);
        return this;
    }
    getMasterVolume() {
        return this.gain.gain.value;
    }
    setMasterVolume(value) {
        this.gain.gain.setTargetAtTime(value, this.context.currentTime, 0.01);
        return this;
    }
    updateMatrixWorld(force) {
        super.updateMatrixWorld(force);
        const listener = this.context.listener;
        const up = this.up;
        this.timeDelta = this._clock.getDelta();
        this.matrixWorld.decompose($d5b85d29c0b78636$var$_position$1, $d5b85d29c0b78636$var$_quaternion$1, $d5b85d29c0b78636$var$_scale$1);
        $d5b85d29c0b78636$var$_orientation$1.set(0, 0, -1).applyQuaternion($d5b85d29c0b78636$var$_quaternion$1);
        if (listener.positionX) {
            // code path for Chrome (see #14393)
            const endTime = this.context.currentTime + this.timeDelta;
            listener.positionX.linearRampToValueAtTime($d5b85d29c0b78636$var$_position$1.x, endTime);
            listener.positionY.linearRampToValueAtTime($d5b85d29c0b78636$var$_position$1.y, endTime);
            listener.positionZ.linearRampToValueAtTime($d5b85d29c0b78636$var$_position$1.z, endTime);
            listener.forwardX.linearRampToValueAtTime($d5b85d29c0b78636$var$_orientation$1.x, endTime);
            listener.forwardY.linearRampToValueAtTime($d5b85d29c0b78636$var$_orientation$1.y, endTime);
            listener.forwardZ.linearRampToValueAtTime($d5b85d29c0b78636$var$_orientation$1.z, endTime);
            listener.upX.linearRampToValueAtTime(up.x, endTime);
            listener.upY.linearRampToValueAtTime(up.y, endTime);
            listener.upZ.linearRampToValueAtTime(up.z, endTime);
        } else {
            listener.setPosition($d5b85d29c0b78636$var$_position$1.x, $d5b85d29c0b78636$var$_position$1.y, $d5b85d29c0b78636$var$_position$1.z);
            listener.setOrientation($d5b85d29c0b78636$var$_orientation$1.x, $d5b85d29c0b78636$var$_orientation$1.y, $d5b85d29c0b78636$var$_orientation$1.z, up.x, up.y, up.z);
        }
    }
}
class $d5b85d29c0b78636$export$153755f98d9861de extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(listener){
        super();
        this.type = 'Audio';
        this.listener = listener;
        this.context = listener.context;
        this.gain = this.context.createGain();
        this.gain.connect(listener.getInput());
        this.autoplay = false;
        this.buffer = null;
        this.detune = 0;
        this.loop = false;
        this.loopStart = 0;
        this.loopEnd = 0;
        this.offset = 0;
        this.duration = undefined;
        this.playbackRate = 1;
        this.isPlaying = false;
        this.hasPlaybackControl = true;
        this.source = null;
        this.sourceType = 'empty';
        this._startedAt = 0;
        this._progress = 0;
        this._connected = false;
        this.filters = [];
    }
    getOutput() {
        return this.gain;
    }
    setNodeSource(audioNode) {
        this.hasPlaybackControl = false;
        this.sourceType = 'audioNode';
        this.source = audioNode;
        this.connect();
        return this;
    }
    setMediaElementSource(mediaElement) {
        this.hasPlaybackControl = false;
        this.sourceType = 'mediaNode';
        this.source = this.context.createMediaElementSource(mediaElement);
        this.connect();
        return this;
    }
    setMediaStreamSource(mediaStream) {
        this.hasPlaybackControl = false;
        this.sourceType = 'mediaStreamNode';
        this.source = this.context.createMediaStreamSource(mediaStream);
        this.connect();
        return this;
    }
    setBuffer(audioBuffer) {
        this.buffer = audioBuffer;
        this.sourceType = 'buffer';
        if (this.autoplay) this.play();
        return this;
    }
    play(delay = 0) {
        if (this.isPlaying === true) {
            console.warn('THREE.Audio: Audio is already playing.');
            return;
        }
        if (this.hasPlaybackControl === false) {
            console.warn('THREE.Audio: this Audio has no playback control.');
            return;
        }
        this._startedAt = this.context.currentTime + delay;
        const source = this.context.createBufferSource();
        source.buffer = this.buffer;
        source.loop = this.loop;
        source.loopStart = this.loopStart;
        source.loopEnd = this.loopEnd;
        source.onended = this.onEnded.bind(this);
        source.start(this._startedAt, this._progress + this.offset, this.duration);
        this.isPlaying = true;
        this.source = source;
        this.setDetune(this.detune);
        this.setPlaybackRate(this.playbackRate);
        return this.connect();
    }
    pause() {
        if (this.hasPlaybackControl === false) {
            console.warn('THREE.Audio: this Audio has no playback control.');
            return;
        }
        if (this.isPlaying === true) {
            // update current progress
            this._progress += Math.max(this.context.currentTime - this._startedAt, 0) * this.playbackRate;
            if (this.loop === true) // ensure _progress does not exceed duration with looped audios
            this._progress = this._progress % (this.duration || this.buffer.duration);
            this.source.stop();
            this.source.onended = null;
            this.isPlaying = false;
        }
        return this;
    }
    stop(delay = 0) {
        if (this.hasPlaybackControl === false) {
            console.warn('THREE.Audio: this Audio has no playback control.');
            return;
        }
        this._progress = 0;
        if (this.source !== null) {
            this.source.stop(this.context.currentTime + delay);
            this.source.onended = null;
        }
        this.isPlaying = false;
        return this;
    }
    connect() {
        if (this.filters.length > 0) {
            this.source.connect(this.filters[0]);
            for(let i = 1, l = this.filters.length; i < l; i++)this.filters[i - 1].connect(this.filters[i]);
            this.filters[this.filters.length - 1].connect(this.getOutput());
        } else this.source.connect(this.getOutput());
        this._connected = true;
        return this;
    }
    disconnect() {
        if (this._connected === false) return;
        if (this.filters.length > 0) {
            this.source.disconnect(this.filters[0]);
            for(let i = 1, l = this.filters.length; i < l; i++)this.filters[i - 1].disconnect(this.filters[i]);
            this.filters[this.filters.length - 1].disconnect(this.getOutput());
        } else this.source.disconnect(this.getOutput());
        this._connected = false;
        return this;
    }
    getFilters() {
        return this.filters;
    }
    setFilters(value) {
        if (!value) value = [];
        if (this._connected === true) {
            this.disconnect();
            this.filters = value.slice();
            this.connect();
        } else this.filters = value.slice();
        return this;
    }
    setDetune(value) {
        this.detune = value;
        if (this.isPlaying === true && this.source.detune !== undefined) this.source.detune.setTargetAtTime(this.detune, this.context.currentTime, 0.01);
        return this;
    }
    getDetune() {
        return this.detune;
    }
    getFilter() {
        return this.getFilters()[0];
    }
    setFilter(filter) {
        return this.setFilters(filter ? [
            filter
        ] : []);
    }
    setPlaybackRate(value) {
        if (this.hasPlaybackControl === false) {
            console.warn('THREE.Audio: this Audio has no playback control.');
            return;
        }
        this.playbackRate = value;
        if (this.isPlaying === true) this.source.playbackRate.setTargetAtTime(this.playbackRate, this.context.currentTime, 0.01);
        return this;
    }
    getPlaybackRate() {
        return this.playbackRate;
    }
    onEnded() {
        this.isPlaying = false;
        this._progress = 0;
    }
    getLoop() {
        if (this.hasPlaybackControl === false) {
            console.warn('THREE.Audio: this Audio has no playback control.');
            return false;
        }
        return this.loop;
    }
    setLoop(value) {
        if (this.hasPlaybackControl === false) {
            console.warn('THREE.Audio: this Audio has no playback control.');
            return;
        }
        this.loop = value;
        if (this.isPlaying === true) this.source.loop = this.loop;
        return this;
    }
    setLoopStart(value) {
        this.loopStart = value;
        return this;
    }
    setLoopEnd(value) {
        this.loopEnd = value;
        return this;
    }
    getVolume() {
        return this.gain.gain.value;
    }
    setVolume(value) {
        this.gain.gain.setTargetAtTime(value, this.context.currentTime, 0.01);
        return this;
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        if (source.sourceType !== 'buffer') {
            console.warn('THREE.Audio: Audio source type cannot be copied.');
            return this;
        }
        this.autoplay = source.autoplay;
        this.buffer = source.buffer;
        this.detune = source.detune;
        this.loop = source.loop;
        this.loopStart = source.loopStart;
        this.loopEnd = source.loopEnd;
        this.offset = source.offset;
        this.duration = source.duration;
        this.playbackRate = source.playbackRate;
        this.hasPlaybackControl = source.hasPlaybackControl;
        this.sourceType = source.sourceType;
        this.filters = source.filters.slice();
        return this;
    }
    clone(recursive) {
        return new this.constructor(this.listener).copy(this, recursive);
    }
}
const $d5b85d29c0b78636$var$_position = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_quaternion = /*@__PURE__*/ new $d5b85d29c0b78636$export$23d6a54f0bbc85a3();
const $d5b85d29c0b78636$var$_scale = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_orientation = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$4b3e397ef1832507 extends $d5b85d29c0b78636$export$153755f98d9861de {
    constructor(listener){
        super(listener);
        this.panner = this.context.createPanner();
        this.panner.panningModel = 'HRTF';
        this.panner.connect(this.gain);
    }
    connect() {
        super.connect();
        this.panner.connect(this.gain);
    }
    disconnect() {
        super.disconnect();
        this.panner.disconnect(this.gain);
    }
    getOutput() {
        return this.panner;
    }
    getRefDistance() {
        return this.panner.refDistance;
    }
    setRefDistance(value) {
        this.panner.refDistance = value;
        return this;
    }
    getRolloffFactor() {
        return this.panner.rolloffFactor;
    }
    setRolloffFactor(value) {
        this.panner.rolloffFactor = value;
        return this;
    }
    getDistanceModel() {
        return this.panner.distanceModel;
    }
    setDistanceModel(value) {
        this.panner.distanceModel = value;
        return this;
    }
    getMaxDistance() {
        return this.panner.maxDistance;
    }
    setMaxDistance(value) {
        this.panner.maxDistance = value;
        return this;
    }
    setDirectionalCone(coneInnerAngle, coneOuterAngle, coneOuterGain) {
        this.panner.coneInnerAngle = coneInnerAngle;
        this.panner.coneOuterAngle = coneOuterAngle;
        this.panner.coneOuterGain = coneOuterGain;
        return this;
    }
    updateMatrixWorld(force) {
        super.updateMatrixWorld(force);
        if (this.hasPlaybackControl === true && this.isPlaying === false) return;
        this.matrixWorld.decompose($d5b85d29c0b78636$var$_position, $d5b85d29c0b78636$var$_quaternion, $d5b85d29c0b78636$var$_scale);
        $d5b85d29c0b78636$var$_orientation.set(0, 0, 1).applyQuaternion($d5b85d29c0b78636$var$_quaternion);
        const panner = this.panner;
        if (panner.positionX) {
            // code path for Chrome and Firefox (see #14393)
            const endTime = this.context.currentTime + this.listener.timeDelta;
            panner.positionX.linearRampToValueAtTime($d5b85d29c0b78636$var$_position.x, endTime);
            panner.positionY.linearRampToValueAtTime($d5b85d29c0b78636$var$_position.y, endTime);
            panner.positionZ.linearRampToValueAtTime($d5b85d29c0b78636$var$_position.z, endTime);
            panner.orientationX.linearRampToValueAtTime($d5b85d29c0b78636$var$_orientation.x, endTime);
            panner.orientationY.linearRampToValueAtTime($d5b85d29c0b78636$var$_orientation.y, endTime);
            panner.orientationZ.linearRampToValueAtTime($d5b85d29c0b78636$var$_orientation.z, endTime);
        } else {
            panner.setPosition($d5b85d29c0b78636$var$_position.x, $d5b85d29c0b78636$var$_position.y, $d5b85d29c0b78636$var$_position.z);
            panner.setOrientation($d5b85d29c0b78636$var$_orientation.x, $d5b85d29c0b78636$var$_orientation.y, $d5b85d29c0b78636$var$_orientation.z);
        }
    }
}
class $d5b85d29c0b78636$export$d47da1ef3d382827 {
    constructor(audio, fftSize = 2048){
        this.analyser = audio.context.createAnalyser();
        this.analyser.fftSize = fftSize;
        this.data = new Uint8Array(this.analyser.frequencyBinCount);
        audio.getOutput().connect(this.analyser);
    }
    getFrequencyData() {
        this.analyser.getByteFrequencyData(this.data);
        return this.data;
    }
    getAverageFrequency() {
        let value = 0;
        const data = this.getFrequencyData();
        for(let i = 0; i < data.length; i++)value += data[i];
        return value / data.length;
    }
}
class $d5b85d29c0b78636$export$dfe0af1ca1acb78a {
    constructor(binding, typeName, valueSize){
        this.binding = binding;
        this.valueSize = valueSize;
        let mixFunction, mixFunctionAdditive, setIdentity;
        // buffer layout: [ incoming | accu0 | accu1 | orig | addAccu | (optional work) ]
        //
        // interpolators can use .buffer as their .result
        // the data then goes to 'incoming'
        //
        // 'accu0' and 'accu1' are used frame-interleaved for
        // the cumulative result and are compared to detect
        // changes
        //
        // 'orig' stores the original state of the property
        //
        // 'add' is used for additive cumulative results
        //
        // 'work' is optional and is only present for quaternion types. It is used
        // to store intermediate quaternion multiplication results
        switch(typeName){
            case 'quaternion':
                mixFunction = this._slerp;
                mixFunctionAdditive = this._slerpAdditive;
                setIdentity = this._setAdditiveIdentityQuaternion;
                this.buffer = new Float64Array(valueSize * 6);
                this._workIndex = 5;
                break;
            case 'string':
            case 'bool':
                mixFunction = this._select;
                // Use the regular mix function and for additive on these types,
                // additive is not relevant for non-numeric types
                mixFunctionAdditive = this._select;
                setIdentity = this._setAdditiveIdentityOther;
                this.buffer = new Array(valueSize * 5);
                break;
            default:
                mixFunction = this._lerp;
                mixFunctionAdditive = this._lerpAdditive;
                setIdentity = this._setAdditiveIdentityNumeric;
                this.buffer = new Float64Array(valueSize * 5);
        }
        this._mixBufferRegion = mixFunction;
        this._mixBufferRegionAdditive = mixFunctionAdditive;
        this._setIdentity = setIdentity;
        this._origIndex = 3;
        this._addIndex = 4;
        this.cumulativeWeight = 0;
        this.cumulativeWeightAdditive = 0;
        this.useCount = 0;
        this.referenceCount = 0;
    }
    // accumulate data in the 'incoming' region into 'accu<i>'
    accumulate(accuIndex, weight) {
        // note: happily accumulating nothing when weight = 0, the caller knows
        // the weight and shouldn't have made the call in the first place
        const buffer = this.buffer, stride = this.valueSize, offset = accuIndex * stride + stride;
        let currentWeight = this.cumulativeWeight;
        if (currentWeight === 0) {
            // accuN := incoming * weight
            for(let i = 0; i !== stride; ++i)buffer[offset + i] = buffer[i];
            currentWeight = weight;
        } else {
            // accuN := accuN + incoming * weight
            currentWeight += weight;
            const mix = weight / currentWeight;
            this._mixBufferRegion(buffer, offset, 0, mix, stride);
        }
        this.cumulativeWeight = currentWeight;
    }
    // accumulate data in the 'incoming' region into 'add'
    accumulateAdditive(weight) {
        const buffer = this.buffer, stride = this.valueSize, offset = stride * this._addIndex;
        if (this.cumulativeWeightAdditive === 0) // add = identity
        this._setIdentity();
        // add := add + incoming * weight
        this._mixBufferRegionAdditive(buffer, offset, 0, weight, stride);
        this.cumulativeWeightAdditive += weight;
    }
    // apply the state of 'accu<i>' to the binding when accus differ
    apply(accuIndex) {
        const stride = this.valueSize, buffer = this.buffer, offset = accuIndex * stride + stride, weight = this.cumulativeWeight, weightAdditive = this.cumulativeWeightAdditive, binding = this.binding;
        this.cumulativeWeight = 0;
        this.cumulativeWeightAdditive = 0;
        if (weight < 1) {
            // accuN := accuN + original * ( 1 - cumulativeWeight )
            const originalValueOffset = stride * this._origIndex;
            this._mixBufferRegion(buffer, offset, originalValueOffset, 1 - weight, stride);
        }
        if (weightAdditive > 0) // accuN := accuN + additive accuN
        this._mixBufferRegionAdditive(buffer, offset, this._addIndex * stride, 1, stride);
        for(let i = stride, e = stride + stride; i !== e; ++i)if (buffer[i] !== buffer[i + stride]) {
            // value has changed -> update scene graph
            binding.setValue(buffer, offset);
            break;
        }
    }
    // remember the state of the bound property and copy it to both accus
    saveOriginalState() {
        const binding = this.binding;
        const buffer = this.buffer, stride = this.valueSize, originalValueOffset = stride * this._origIndex;
        binding.getValue(buffer, originalValueOffset);
        // accu[0..1] := orig -- initially detect changes against the original
        for(let i = stride, e = originalValueOffset; i !== e; ++i)buffer[i] = buffer[originalValueOffset + i % stride];
        // Add to identity for additive
        this._setIdentity();
        this.cumulativeWeight = 0;
        this.cumulativeWeightAdditive = 0;
    }
    // apply the state previously taken via 'saveOriginalState' to the binding
    restoreOriginalState() {
        const originalValueOffset = this.valueSize * 3;
        this.binding.setValue(this.buffer, originalValueOffset);
    }
    _setAdditiveIdentityNumeric() {
        const startIndex = this._addIndex * this.valueSize;
        const endIndex = startIndex + this.valueSize;
        for(let i = startIndex; i < endIndex; i++)this.buffer[i] = 0;
    }
    _setAdditiveIdentityQuaternion() {
        this._setAdditiveIdentityNumeric();
        this.buffer[this._addIndex * this.valueSize + 3] = 1;
    }
    _setAdditiveIdentityOther() {
        const startIndex = this._origIndex * this.valueSize;
        const targetIndex = this._addIndex * this.valueSize;
        for(let i = 0; i < this.valueSize; i++)this.buffer[targetIndex + i] = this.buffer[startIndex + i];
    }
    // mix functions
    _select(buffer, dstOffset, srcOffset, t, stride) {
        if (t >= 0.5) for(let i = 0; i !== stride; ++i)buffer[dstOffset + i] = buffer[srcOffset + i];
    }
    _slerp(buffer, dstOffset, srcOffset, t) {
        $d5b85d29c0b78636$export$23d6a54f0bbc85a3.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t);
    }
    _slerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
        const workOffset = this._workIndex * stride;
        // Store result in intermediate buffer offset
        $d5b85d29c0b78636$export$23d6a54f0bbc85a3.multiplyQuaternionsFlat(buffer, workOffset, buffer, dstOffset, buffer, srcOffset);
        // Slerp to the intermediate result
        $d5b85d29c0b78636$export$23d6a54f0bbc85a3.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t);
    }
    _lerp(buffer, dstOffset, srcOffset, t, stride) {
        const s = 1 - t;
        for(let i = 0; i !== stride; ++i){
            const j = dstOffset + i;
            buffer[j] = buffer[j] * s + buffer[srcOffset + i] * t;
        }
    }
    _lerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
        for(let i = 0; i !== stride; ++i){
            const j = dstOffset + i;
            buffer[j] = buffer[j] + buffer[srcOffset + i] * t;
        }
    }
}
// Characters [].:/ are reserved for track binding syntax.
const $d5b85d29c0b78636$var$_RESERVED_CHARS_RE = '\\[\\]\\.:\\/';
const $d5b85d29c0b78636$var$_reservedRe = new RegExp('[' + $d5b85d29c0b78636$var$_RESERVED_CHARS_RE + ']', 'g');
// Attempts to allow node names from any language. ES5's `\w` regexp matches
// only latin characters, and the unicode \p{L} is not yet supported. So
// instead, we exclude reserved characters and match everything else.
const $d5b85d29c0b78636$var$_wordChar = '[^' + $d5b85d29c0b78636$var$_RESERVED_CHARS_RE + ']';
const $d5b85d29c0b78636$var$_wordCharOrDot = '[^' + $d5b85d29c0b78636$var$_RESERVED_CHARS_RE.replace('\\.', '') + ']';
// Parent directories, delimited by '/' or ':'. Currently unused, but must
// be matched to parse the rest of the track name.
const $d5b85d29c0b78636$var$_directoryRe = /*@__PURE__*/ /((?:WC+[\/:])*)/.source.replace('WC', $d5b85d29c0b78636$var$_wordChar);
// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.
const $d5b85d29c0b78636$var$_nodeRe = /*@__PURE__*/ /(WCOD+)?/.source.replace('WCOD', $d5b85d29c0b78636$var$_wordCharOrDot);
// Object on target node, and accessor. May not contain reserved
// characters. Accessor may contain any character except closing bracket.
const $d5b85d29c0b78636$var$_objectRe = /*@__PURE__*/ /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace('WC', $d5b85d29c0b78636$var$_wordChar);
// Property and accessor. May not contain reserved characters. Accessor may
// contain any non-bracket characters.
const $d5b85d29c0b78636$var$_propertyRe = /*@__PURE__*/ /\.(WC+)(?:\[(.+)\])?/.source.replace('WC', $d5b85d29c0b78636$var$_wordChar);
const $d5b85d29c0b78636$var$_trackRe = new RegExp("^" + $d5b85d29c0b78636$var$_directoryRe + $d5b85d29c0b78636$var$_nodeRe + $d5b85d29c0b78636$var$_objectRe + $d5b85d29c0b78636$var$_propertyRe + '$');
const $d5b85d29c0b78636$var$_supportedObjectNames = [
    'material',
    'materials',
    'bones',
    'map'
];
class $d5b85d29c0b78636$var$Composite {
    constructor(targetGroup, path, optionalParsedPath){
        const parsedPath = optionalParsedPath || $d5b85d29c0b78636$export$7bf70fcf9f891893.parseTrackName(path);
        this._targetGroup = targetGroup;
        this._bindings = targetGroup.subscribe_(path, parsedPath);
    }
    getValue(array, offset) {
        this.bind(); // bind all binding
        const firstValidIndex = this._targetGroup.nCachedObjects_, binding = this._bindings[firstValidIndex];
        // and only call .getValue on the first
        if (binding !== undefined) binding.getValue(array, offset);
    }
    setValue(array, offset) {
        const bindings = this._bindings;
        for(let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i)bindings[i].setValue(array, offset);
    }
    bind() {
        const bindings = this._bindings;
        for(let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i)bindings[i].bind();
    }
    unbind() {
        const bindings = this._bindings;
        for(let i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i)bindings[i].unbind();
    }
}
// Note: This class uses a State pattern on a per-method basis:
// 'bind' sets 'this.getValue' / 'setValue' and shadows the
// prototype version of these methods with one that represents
// the bound state. When the property is not found, the methods
// become no-ops.
class $d5b85d29c0b78636$export$7bf70fcf9f891893 {
    constructor(rootNode, path, parsedPath){
        this.path = path;
        this.parsedPath = parsedPath || $d5b85d29c0b78636$export$7bf70fcf9f891893.parseTrackName(path);
        this.node = $d5b85d29c0b78636$export$7bf70fcf9f891893.findNode(rootNode, this.parsedPath.nodeName);
        this.rootNode = rootNode;
        // initial state of these methods that calls 'bind'
        this.getValue = this._getValue_unbound;
        this.setValue = this._setValue_unbound;
    }
    static create(root, path, parsedPath) {
        if (!(root && root.isAnimationObjectGroup)) return new $d5b85d29c0b78636$export$7bf70fcf9f891893(root, path, parsedPath);
        else return new $d5b85d29c0b78636$export$7bf70fcf9f891893.Composite(root, path, parsedPath);
    }
    /**
	 * Replaces spaces with underscores and removes unsupported characters from
	 * node names, to ensure compatibility with parseTrackName().
	 *
	 * @param {string} name Node name to be sanitized.
	 * @return {string}
	 */ static sanitizeNodeName(name) {
        return name.replace(/\s/g, '_').replace($d5b85d29c0b78636$var$_reservedRe, '');
    }
    static parseTrackName(trackName) {
        const matches = $d5b85d29c0b78636$var$_trackRe.exec(trackName);
        if (matches === null) throw new Error('PropertyBinding: Cannot parse trackName: ' + trackName);
        const results = {
            // directoryName: matches[ 1 ], // (tschw) currently unused
            nodeName: matches[2],
            objectName: matches[3],
            objectIndex: matches[4],
            propertyName: matches[5],
            propertyIndex: matches[6]
        };
        const lastDot = results.nodeName && results.nodeName.lastIndexOf('.');
        if (lastDot !== undefined && lastDot !== -1) {
            const objectName = results.nodeName.substring(lastDot + 1);
            // Object names must be checked against an allowlist. Otherwise, there
            // is no way to parse 'foo.bar.baz': 'baz' must be a property, but
            // 'bar' could be the objectName, or part of a nodeName (which can
            // include '.' characters).
            if ($d5b85d29c0b78636$var$_supportedObjectNames.indexOf(objectName) !== -1) {
                results.nodeName = results.nodeName.substring(0, lastDot);
                results.objectName = objectName;
            }
        }
        if (results.propertyName === null || results.propertyName.length === 0) throw new Error('PropertyBinding: can not parse propertyName from trackName: ' + trackName);
        return results;
    }
    static findNode(root, nodeName) {
        if (nodeName === undefined || nodeName === '' || nodeName === '.' || nodeName === -1 || nodeName === root.name || nodeName === root.uuid) return root;
        // search into skeleton bones.
        if (root.skeleton) {
            const bone = root.skeleton.getBoneByName(nodeName);
            if (bone !== undefined) return bone;
        }
        // search into node subtree.
        if (root.children) {
            const searchNodeSubtree = function(children) {
                for(let i = 0; i < children.length; i++){
                    const childNode = children[i];
                    if (childNode.name === nodeName || childNode.uuid === nodeName) return childNode;
                    const result = searchNodeSubtree(childNode.children);
                    if (result) return result;
                }
                return null;
            };
            const subTreeNode = searchNodeSubtree(root.children);
            if (subTreeNode) return subTreeNode;
        }
        return null;
    }
    // these are used to "bind" a nonexistent property
    _getValue_unavailable() {}
    _setValue_unavailable() {}
    // Getters
    _getValue_direct(buffer, offset) {
        buffer[offset] = this.targetObject[this.propertyName];
    }
    _getValue_array(buffer, offset) {
        const source = this.resolvedProperty;
        for(let i = 0, n = source.length; i !== n; ++i)buffer[offset++] = source[i];
    }
    _getValue_arrayElement(buffer, offset) {
        buffer[offset] = this.resolvedProperty[this.propertyIndex];
    }
    _getValue_toArray(buffer, offset) {
        this.resolvedProperty.toArray(buffer, offset);
    }
    // Direct
    _setValue_direct(buffer, offset) {
        this.targetObject[this.propertyName] = buffer[offset];
    }
    _setValue_direct_setNeedsUpdate(buffer, offset) {
        this.targetObject[this.propertyName] = buffer[offset];
        this.targetObject.needsUpdate = true;
    }
    _setValue_direct_setMatrixWorldNeedsUpdate(buffer, offset) {
        this.targetObject[this.propertyName] = buffer[offset];
        this.targetObject.matrixWorldNeedsUpdate = true;
    }
    // EntireArray
    _setValue_array(buffer, offset) {
        const dest = this.resolvedProperty;
        for(let i = 0, n = dest.length; i !== n; ++i)dest[i] = buffer[offset++];
    }
    _setValue_array_setNeedsUpdate(buffer, offset) {
        const dest = this.resolvedProperty;
        for(let i = 0, n = dest.length; i !== n; ++i)dest[i] = buffer[offset++];
        this.targetObject.needsUpdate = true;
    }
    _setValue_array_setMatrixWorldNeedsUpdate(buffer, offset) {
        const dest = this.resolvedProperty;
        for(let i = 0, n = dest.length; i !== n; ++i)dest[i] = buffer[offset++];
        this.targetObject.matrixWorldNeedsUpdate = true;
    }
    // ArrayElement
    _setValue_arrayElement(buffer, offset) {
        this.resolvedProperty[this.propertyIndex] = buffer[offset];
    }
    _setValue_arrayElement_setNeedsUpdate(buffer, offset) {
        this.resolvedProperty[this.propertyIndex] = buffer[offset];
        this.targetObject.needsUpdate = true;
    }
    _setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer, offset) {
        this.resolvedProperty[this.propertyIndex] = buffer[offset];
        this.targetObject.matrixWorldNeedsUpdate = true;
    }
    // HasToFromArray
    _setValue_fromArray(buffer, offset) {
        this.resolvedProperty.fromArray(buffer, offset);
    }
    _setValue_fromArray_setNeedsUpdate(buffer, offset) {
        this.resolvedProperty.fromArray(buffer, offset);
        this.targetObject.needsUpdate = true;
    }
    _setValue_fromArray_setMatrixWorldNeedsUpdate(buffer, offset) {
        this.resolvedProperty.fromArray(buffer, offset);
        this.targetObject.matrixWorldNeedsUpdate = true;
    }
    _getValue_unbound(targetArray, offset) {
        this.bind();
        this.getValue(targetArray, offset);
    }
    _setValue_unbound(sourceArray, offset) {
        this.bind();
        this.setValue(sourceArray, offset);
    }
    // create getter / setter pair for a property in the scene graph
    bind() {
        let targetObject = this.node;
        const parsedPath = this.parsedPath;
        const objectName = parsedPath.objectName;
        const propertyName = parsedPath.propertyName;
        let propertyIndex = parsedPath.propertyIndex;
        if (!targetObject) {
            targetObject = $d5b85d29c0b78636$export$7bf70fcf9f891893.findNode(this.rootNode, parsedPath.nodeName);
            this.node = targetObject;
        }
        // set fail state so we can just 'return' on error
        this.getValue = this._getValue_unavailable;
        this.setValue = this._setValue_unavailable;
        // ensure there is a value node
        if (!targetObject) {
            console.warn('THREE.PropertyBinding: No target node found for track: ' + this.path + '.');
            return;
        }
        if (objectName) {
            let objectIndex = parsedPath.objectIndex;
            // special cases were we need to reach deeper into the hierarchy to get the face materials....
            switch(objectName){
                case 'materials':
                    if (!targetObject.material) {
                        console.error('THREE.PropertyBinding: Can not bind to material as node does not have a material.', this);
                        return;
                    }
                    if (!targetObject.material.materials) {
                        console.error('THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this);
                        return;
                    }
                    targetObject = targetObject.material.materials;
                    break;
                case 'bones':
                    if (!targetObject.skeleton) {
                        console.error('THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this);
                        return;
                    }
                    // potential future optimization: skip this if propertyIndex is already an integer
                    // and convert the integer string to a true integer.
                    targetObject = targetObject.skeleton.bones;
                    // support resolving morphTarget names into indices.
                    for(let i = 0; i < targetObject.length; i++)if (targetObject[i].name === objectIndex) {
                        objectIndex = i;
                        break;
                    }
                    break;
                case 'map':
                    if ('map' in targetObject) {
                        targetObject = targetObject.map;
                        break;
                    }
                    if (!targetObject.material) {
                        console.error('THREE.PropertyBinding: Can not bind to material as node does not have a material.', this);
                        return;
                    }
                    if (!targetObject.material.map) {
                        console.error('THREE.PropertyBinding: Can not bind to material.map as node.material does not have a map.', this);
                        return;
                    }
                    targetObject = targetObject.material.map;
                    break;
                default:
                    if (targetObject[objectName] === undefined) {
                        console.error('THREE.PropertyBinding: Can not bind to objectName of node undefined.', this);
                        return;
                    }
                    targetObject = targetObject[objectName];
            }
            if (objectIndex !== undefined) {
                if (targetObject[objectIndex] === undefined) {
                    console.error('THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject);
                    return;
                }
                targetObject = targetObject[objectIndex];
            }
        }
        // resolve property
        const nodeProperty = targetObject[propertyName];
        if (nodeProperty === undefined) {
            const nodeName = parsedPath.nodeName;
            console.error('THREE.PropertyBinding: Trying to update property for track: ' + nodeName + '.' + propertyName + ' but it wasn\'t found.', targetObject);
            return;
        }
        // determine versioning scheme
        let versioning = this.Versioning.None;
        this.targetObject = targetObject;
        if (targetObject.isMaterial === true) versioning = this.Versioning.NeedsUpdate;
        else if (targetObject.isObject3D === true) versioning = this.Versioning.MatrixWorldNeedsUpdate;
        // determine how the property gets bound
        let bindingType = this.BindingType.Direct;
        if (propertyIndex !== undefined) {
            // access a sub element of the property array (only primitives are supported right now)
            if (propertyName === 'morphTargetInfluences') {
                // potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.
                // support resolving morphTarget names into indices.
                if (!targetObject.geometry) {
                    console.error('THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this);
                    return;
                }
                if (!targetObject.geometry.morphAttributes) {
                    console.error('THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this);
                    return;
                }
                if (targetObject.morphTargetDictionary[propertyIndex] !== undefined) propertyIndex = targetObject.morphTargetDictionary[propertyIndex];
            }
            bindingType = this.BindingType.ArrayElement;
            this.resolvedProperty = nodeProperty;
            this.propertyIndex = propertyIndex;
        } else if (nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined) {
            // must use copy for Object3D.Euler/Quaternion
            bindingType = this.BindingType.HasFromToArray;
            this.resolvedProperty = nodeProperty;
        } else if (Array.isArray(nodeProperty)) {
            bindingType = this.BindingType.EntireArray;
            this.resolvedProperty = nodeProperty;
        } else this.propertyName = propertyName;
        // select getter / setter
        this.getValue = this.GetterByBindingType[bindingType];
        this.setValue = this.SetterByBindingTypeAndVersioning[bindingType][versioning];
    }
    unbind() {
        this.node = null;
        // back to the prototype version of getValue / setValue
        // note: avoiding to mutate the shape of 'this' via 'delete'
        this.getValue = this._getValue_unbound;
        this.setValue = this._setValue_unbound;
    }
}
$d5b85d29c0b78636$export$7bf70fcf9f891893.Composite = $d5b85d29c0b78636$var$Composite;
$d5b85d29c0b78636$export$7bf70fcf9f891893.prototype.BindingType = {
    Direct: 0,
    EntireArray: 1,
    ArrayElement: 2,
    HasFromToArray: 3
};
$d5b85d29c0b78636$export$7bf70fcf9f891893.prototype.Versioning = {
    None: 0,
    NeedsUpdate: 1,
    MatrixWorldNeedsUpdate: 2
};
$d5b85d29c0b78636$export$7bf70fcf9f891893.prototype.GetterByBindingType = [
    $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._getValue_direct,
    $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._getValue_array,
    $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._getValue_arrayElement,
    $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._getValue_toArray
];
$d5b85d29c0b78636$export$7bf70fcf9f891893.prototype.SetterByBindingTypeAndVersioning = [
    [
        // Direct
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_direct,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_direct_setNeedsUpdate,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_direct_setMatrixWorldNeedsUpdate
    ],
    [
        // EntireArray
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_array,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_array_setNeedsUpdate,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_array_setMatrixWorldNeedsUpdate
    ],
    [
        // ArrayElement
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_arrayElement,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_arrayElement_setNeedsUpdate,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_arrayElement_setMatrixWorldNeedsUpdate
    ],
    [
        // HasToFromArray
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_fromArray,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_fromArray_setNeedsUpdate,
        $d5b85d29c0b78636$export$7bf70fcf9f891893.prototype._setValue_fromArray_setMatrixWorldNeedsUpdate
    ]
];
/**
 *
 * A group of objects that receives a shared animation state.
 *
 * Usage:
 *
 *  - Add objects you would otherwise pass as 'root' to the
 *    constructor or the .clipAction method of AnimationMixer.
 *
 *  - Instead pass this object as 'root'.
 *
 *  - You can also add and remove objects later when the mixer
 *    is running.
 *
 * Note:
 *
 *    Objects of this class appear as one object to the mixer,
 *    so cache control of the individual objects must be done
 *    on the group.
 *
 * Limitation:
 *
 *  - The animated properties must be compatible among the
 *    all objects in the group.
 *
 *  - A single property can either be controlled through a
 *    target group or directly, but not both.
 */ class $d5b85d29c0b78636$export$30619c2afd3f34db {
    constructor(){
        this.isAnimationObjectGroup = true;
        this.uuid = $d5b85d29c0b78636$var$generateUUID();
        // cached objects followed by the active ones
        this._objects = Array.prototype.slice.call(arguments);
        this.nCachedObjects_ = 0; // threshold
        // note: read by PropertyBinding.Composite
        const indices = {};
        this._indicesByUUID = indices; // for bookkeeping
        for(let i = 0, n = arguments.length; i !== n; ++i)indices[arguments[i].uuid] = i;
        this._paths = []; // inside: string
        this._parsedPaths = []; // inside: { we don't care, here }
        this._bindings = []; // inside: Array< PropertyBinding >
        this._bindingsIndicesByPath = {}; // inside: indices in these arrays
        const scope = this;
        this.stats = {
            objects: {
                get total () {
                    return scope._objects.length;
                },
                get inUse () {
                    return this.total - scope.nCachedObjects_;
                }
            },
            get bindingsPerObject () {
                return scope._bindings.length;
            }
        };
    }
    add() {
        const objects = this._objects, indicesByUUID = this._indicesByUUID, paths = this._paths, parsedPaths = this._parsedPaths, bindings = this._bindings, nBindings = bindings.length;
        let knownObject = undefined, nObjects = objects.length, nCachedObjects = this.nCachedObjects_;
        for(let i = 0, n = arguments.length; i !== n; ++i){
            const object = arguments[i], uuid = object.uuid;
            let index = indicesByUUID[uuid];
            if (index === undefined) {
                // unknown object -> add it to the ACTIVE region
                index = nObjects++;
                indicesByUUID[uuid] = index;
                objects.push(object);
                // accounting is done, now do the same for all bindings
                for(let j = 0, m = nBindings; j !== m; ++j)bindings[j].push(new $d5b85d29c0b78636$export$7bf70fcf9f891893(object, paths[j], parsedPaths[j]));
            } else if (index < nCachedObjects) {
                knownObject = objects[index];
                // move existing object to the ACTIVE region
                const firstActiveIndex = --nCachedObjects, lastCachedObject = objects[firstActiveIndex];
                indicesByUUID[lastCachedObject.uuid] = index;
                objects[index] = lastCachedObject;
                indicesByUUID[uuid] = firstActiveIndex;
                objects[firstActiveIndex] = object;
                // accounting is done, now do the same for all bindings
                for(let j = 0, m = nBindings; j !== m; ++j){
                    const bindingsForPath = bindings[j], lastCached = bindingsForPath[firstActiveIndex];
                    let binding = bindingsForPath[index];
                    bindingsForPath[index] = lastCached;
                    if (binding === undefined) // since we do not bother to create new bindings
                    // for objects that are cached, the binding may
                    // or may not exist
                    binding = new $d5b85d29c0b78636$export$7bf70fcf9f891893(object, paths[j], parsedPaths[j]);
                    bindingsForPath[firstActiveIndex] = binding;
                }
            } else if (objects[index] !== knownObject) console.error("THREE.AnimationObjectGroup: Different objects with the same UUID detected. Clean the caches or recreate your infrastructure when reloading scenes.");
             // else the object is already where we want it to be
        } // for arguments
        this.nCachedObjects_ = nCachedObjects;
    }
    remove() {
        const objects = this._objects, indicesByUUID = this._indicesByUUID, bindings = this._bindings, nBindings = bindings.length;
        let nCachedObjects = this.nCachedObjects_;
        for(let i = 0, n = arguments.length; i !== n; ++i){
            const object = arguments[i], uuid = object.uuid, index = indicesByUUID[uuid];
            if (index !== undefined && index >= nCachedObjects) {
                // move existing object into the CACHED region
                const lastCachedIndex = nCachedObjects++, firstActiveObject = objects[lastCachedIndex];
                indicesByUUID[firstActiveObject.uuid] = index;
                objects[index] = firstActiveObject;
                indicesByUUID[uuid] = lastCachedIndex;
                objects[lastCachedIndex] = object;
                // accounting is done, now do the same for all bindings
                for(let j = 0, m = nBindings; j !== m; ++j){
                    const bindingsForPath = bindings[j], firstActive = bindingsForPath[lastCachedIndex], binding = bindingsForPath[index];
                    bindingsForPath[index] = firstActive;
                    bindingsForPath[lastCachedIndex] = binding;
                }
            }
        } // for arguments
        this.nCachedObjects_ = nCachedObjects;
    }
    // remove & forget
    uncache() {
        const objects = this._objects, indicesByUUID = this._indicesByUUID, bindings = this._bindings, nBindings = bindings.length;
        let nCachedObjects = this.nCachedObjects_, nObjects = objects.length;
        for(let i = 0, n = arguments.length; i !== n; ++i){
            const object = arguments[i], uuid = object.uuid, index = indicesByUUID[uuid];
            if (index !== undefined) {
                delete indicesByUUID[uuid];
                if (index < nCachedObjects) {
                    // object is cached, shrink the CACHED region
                    const firstActiveIndex = --nCachedObjects, lastCachedObject = objects[firstActiveIndex], lastIndex = --nObjects, lastObject = objects[lastIndex];
                    // last cached object takes this object's place
                    indicesByUUID[lastCachedObject.uuid] = index;
                    objects[index] = lastCachedObject;
                    // last object goes to the activated slot and pop
                    indicesByUUID[lastObject.uuid] = firstActiveIndex;
                    objects[firstActiveIndex] = lastObject;
                    objects.pop();
                    // accounting is done, now do the same for all bindings
                    for(let j = 0, m = nBindings; j !== m; ++j){
                        const bindingsForPath = bindings[j], lastCached = bindingsForPath[firstActiveIndex], last = bindingsForPath[lastIndex];
                        bindingsForPath[index] = lastCached;
                        bindingsForPath[firstActiveIndex] = last;
                        bindingsForPath.pop();
                    }
                } else {
                    // object is active, just swap with the last and pop
                    const lastIndex = --nObjects, lastObject = objects[lastIndex];
                    if (lastIndex > 0) indicesByUUID[lastObject.uuid] = index;
                    objects[index] = lastObject;
                    objects.pop();
                    // accounting is done, now do the same for all bindings
                    for(let j = 0, m = nBindings; j !== m; ++j){
                        const bindingsForPath = bindings[j];
                        bindingsForPath[index] = bindingsForPath[lastIndex];
                        bindingsForPath.pop();
                    }
                } // cached or active
            } // if object is known
        } // for arguments
        this.nCachedObjects_ = nCachedObjects;
    }
    // Internal interface used by befriended PropertyBinding.Composite:
    subscribe_(path, parsedPath) {
        // returns an array of bindings for the given path that is changed
        // according to the contained objects in the group
        const indicesByPath = this._bindingsIndicesByPath;
        let index = indicesByPath[path];
        const bindings = this._bindings;
        if (index !== undefined) return bindings[index];
        const paths = this._paths, parsedPaths = this._parsedPaths, objects = this._objects, nObjects = objects.length, nCachedObjects = this.nCachedObjects_, bindingsForPath = new Array(nObjects);
        index = bindings.length;
        indicesByPath[path] = index;
        paths.push(path);
        parsedPaths.push(parsedPath);
        bindings.push(bindingsForPath);
        for(let i = nCachedObjects, n = objects.length; i !== n; ++i){
            const object = objects[i];
            bindingsForPath[i] = new $d5b85d29c0b78636$export$7bf70fcf9f891893(object, path, parsedPath);
        }
        return bindingsForPath;
    }
    unsubscribe_(path) {
        // tells the group to forget about a property path and no longer
        // update the array previously obtained with 'subscribe_'
        const indicesByPath = this._bindingsIndicesByPath, index = indicesByPath[path];
        if (index !== undefined) {
            const paths = this._paths, parsedPaths = this._parsedPaths, bindings = this._bindings, lastBindingsIndex = bindings.length - 1, lastBindings = bindings[lastBindingsIndex], lastBindingsPath = path[lastBindingsIndex];
            indicesByPath[lastBindingsPath] = index;
            bindings[index] = lastBindings;
            bindings.pop();
            parsedPaths[index] = parsedPaths[lastBindingsIndex];
            parsedPaths.pop();
            paths[index] = paths[lastBindingsIndex];
            paths.pop();
        }
    }
}
class $d5b85d29c0b78636$export$6946940a69e799e {
    constructor(mixer, clip, localRoot = null, blendMode = clip.blendMode){
        this._mixer = mixer;
        this._clip = clip;
        this._localRoot = localRoot;
        this.blendMode = blendMode;
        const tracks = clip.tracks, nTracks = tracks.length, interpolants = new Array(nTracks);
        const interpolantSettings = {
            endingStart: $d5b85d29c0b78636$export$7f795934b84ab523,
            endingEnd: $d5b85d29c0b78636$export$7f795934b84ab523
        };
        for(let i = 0; i !== nTracks; ++i){
            const interpolant = tracks[i].createInterpolant(null);
            interpolants[i] = interpolant;
            interpolant.settings = interpolantSettings;
        }
        this._interpolantSettings = interpolantSettings;
        this._interpolants = interpolants; // bound by the mixer
        // inside: PropertyMixer (managed by the mixer)
        this._propertyBindings = new Array(nTracks);
        this._cacheIndex = null; // for the memory manager
        this._byClipCacheIndex = null; // for the memory manager
        this._timeScaleInterpolant = null;
        this._weightInterpolant = null;
        this.loop = $d5b85d29c0b78636$export$dfaf4422ce096e29;
        this._loopCount = -1;
        // global mixer time when the action is to be started
        // it's set back to 'null' upon start of the action
        this._startTime = null;
        // scaled local time of the action
        // gets clamped or wrapped to 0..clip.duration according to loop
        this.time = 0;
        this.timeScale = 1;
        this._effectiveTimeScale = 1;
        this.weight = 1;
        this._effectiveWeight = 1;
        this.repetitions = Infinity; // no. of repetitions when looping
        this.paused = false; // true -> zero effective time scale
        this.enabled = true; // false -> zero effective weight
        this.clampWhenFinished = false; // keep feeding the last frame?
        this.zeroSlopeAtStart = true; // for smooth interpolation w/o separate
        this.zeroSlopeAtEnd = true; // clips for start, loop and end
    }
    // State & Scheduling
    play() {
        this._mixer._activateAction(this);
        return this;
    }
    stop() {
        this._mixer._deactivateAction(this);
        return this.reset();
    }
    reset() {
        this.paused = false;
        this.enabled = true;
        this.time = 0; // restart clip
        this._loopCount = -1; // forget previous loops
        this._startTime = null; // forget scheduling
        return this.stopFading().stopWarping();
    }
    isRunning() {
        return this.enabled && !this.paused && this.timeScale !== 0 && this._startTime === null && this._mixer._isActiveAction(this);
    }
    // return true when play has been called
    isScheduled() {
        return this._mixer._isActiveAction(this);
    }
    startAt(time) {
        this._startTime = time;
        return this;
    }
    setLoop(mode, repetitions) {
        this.loop = mode;
        this.repetitions = repetitions;
        return this;
    }
    // Weight
    // set the weight stopping any scheduled fading
    // although .enabled = false yields an effective weight of zero, this
    // method does *not* change .enabled, because it would be confusing
    setEffectiveWeight(weight) {
        this.weight = weight;
        // note: same logic as when updated at runtime
        this._effectiveWeight = this.enabled ? weight : 0;
        return this.stopFading();
    }
    // return the weight considering fading and .enabled
    getEffectiveWeight() {
        return this._effectiveWeight;
    }
    fadeIn(duration) {
        return this._scheduleFading(duration, 0, 1);
    }
    fadeOut(duration) {
        return this._scheduleFading(duration, 1, 0);
    }
    crossFadeFrom(fadeOutAction, duration, warp) {
        fadeOutAction.fadeOut(duration);
        this.fadeIn(duration);
        if (warp) {
            const fadeInDuration = this._clip.duration, fadeOutDuration = fadeOutAction._clip.duration, startEndRatio = fadeOutDuration / fadeInDuration, endStartRatio = fadeInDuration / fadeOutDuration;
            fadeOutAction.warp(1.0, startEndRatio, duration);
            this.warp(endStartRatio, 1.0, duration);
        }
        return this;
    }
    crossFadeTo(fadeInAction, duration, warp) {
        return fadeInAction.crossFadeFrom(this, duration, warp);
    }
    stopFading() {
        const weightInterpolant = this._weightInterpolant;
        if (weightInterpolant !== null) {
            this._weightInterpolant = null;
            this._mixer._takeBackControlInterpolant(weightInterpolant);
        }
        return this;
    }
    // Time Scale Control
    // set the time scale stopping any scheduled warping
    // although .paused = true yields an effective time scale of zero, this
    // method does *not* change .paused, because it would be confusing
    setEffectiveTimeScale(timeScale) {
        this.timeScale = timeScale;
        this._effectiveTimeScale = this.paused ? 0 : timeScale;
        return this.stopWarping();
    }
    // return the time scale considering warping and .paused
    getEffectiveTimeScale() {
        return this._effectiveTimeScale;
    }
    setDuration(duration) {
        this.timeScale = this._clip.duration / duration;
        return this.stopWarping();
    }
    syncWith(action) {
        this.time = action.time;
        this.timeScale = action.timeScale;
        return this.stopWarping();
    }
    halt(duration) {
        return this.warp(this._effectiveTimeScale, 0, duration);
    }
    warp(startTimeScale, endTimeScale, duration) {
        const mixer = this._mixer, now = mixer.time, timeScale = this.timeScale;
        let interpolant = this._timeScaleInterpolant;
        if (interpolant === null) {
            interpolant = mixer._lendControlInterpolant();
            this._timeScaleInterpolant = interpolant;
        }
        const times = interpolant.parameterPositions, values = interpolant.sampleValues;
        times[0] = now;
        times[1] = now + duration;
        values[0] = startTimeScale / timeScale;
        values[1] = endTimeScale / timeScale;
        return this;
    }
    stopWarping() {
        const timeScaleInterpolant = this._timeScaleInterpolant;
        if (timeScaleInterpolant !== null) {
            this._timeScaleInterpolant = null;
            this._mixer._takeBackControlInterpolant(timeScaleInterpolant);
        }
        return this;
    }
    // Object Accessors
    getMixer() {
        return this._mixer;
    }
    getClip() {
        return this._clip;
    }
    getRoot() {
        return this._localRoot || this._mixer._root;
    }
    // Interna
    _update(time, deltaTime, timeDirection, accuIndex) {
        // called by the mixer
        if (!this.enabled) {
            // call ._updateWeight() to update ._effectiveWeight
            this._updateWeight(time);
            return;
        }
        const startTime = this._startTime;
        if (startTime !== null) {
            // check for scheduled start of action
            const timeRunning = (time - startTime) * timeDirection;
            if (timeRunning < 0 || timeDirection === 0) deltaTime = 0;
            else {
                this._startTime = null; // unschedule
                deltaTime = timeDirection * timeRunning;
            }
        }
        // apply time scale and advance time
        deltaTime *= this._updateTimeScale(time);
        const clipTime = this._updateTime(deltaTime);
        // note: _updateTime may disable the action resulting in
        // an effective weight of 0
        const weight = this._updateWeight(time);
        if (weight > 0) {
            const interpolants = this._interpolants;
            const propertyMixers = this._propertyBindings;
            switch(this.blendMode){
                case $d5b85d29c0b78636$export$d875e029ef558d3:
                    for(let j = 0, m = interpolants.length; j !== m; ++j){
                        interpolants[j].evaluate(clipTime);
                        propertyMixers[j].accumulateAdditive(weight);
                    }
                    break;
                case $d5b85d29c0b78636$export$bcfbbdcf8de7f8cd:
                default:
                    for(let j = 0, m = interpolants.length; j !== m; ++j){
                        interpolants[j].evaluate(clipTime);
                        propertyMixers[j].accumulate(accuIndex, weight);
                    }
            }
        }
    }
    _updateWeight(time) {
        let weight = 0;
        if (this.enabled) {
            weight = this.weight;
            const interpolant = this._weightInterpolant;
            if (interpolant !== null) {
                const interpolantValue = interpolant.evaluate(time)[0];
                weight *= interpolantValue;
                if (time > interpolant.parameterPositions[1]) {
                    this.stopFading();
                    if (interpolantValue === 0) // faded out, disable
                    this.enabled = false;
                }
            }
        }
        this._effectiveWeight = weight;
        return weight;
    }
    _updateTimeScale(time) {
        let timeScale = 0;
        if (!this.paused) {
            timeScale = this.timeScale;
            const interpolant = this._timeScaleInterpolant;
            if (interpolant !== null) {
                const interpolantValue = interpolant.evaluate(time)[0];
                timeScale *= interpolantValue;
                if (time > interpolant.parameterPositions[1]) {
                    this.stopWarping();
                    if (timeScale === 0) // motion has halted, pause
                    this.paused = true;
                    else // warp done - apply final time scale
                    this.timeScale = timeScale;
                }
            }
        }
        this._effectiveTimeScale = timeScale;
        return timeScale;
    }
    _updateTime(deltaTime) {
        const duration = this._clip.duration;
        const loop = this.loop;
        let time = this.time + deltaTime;
        let loopCount = this._loopCount;
        const pingPong = loop === $d5b85d29c0b78636$export$f8f6f2041b78e210;
        if (deltaTime === 0) {
            if (loopCount === -1) return time;
            return pingPong && (loopCount & 1) === 1 ? duration - time : time;
        }
        if (loop === $d5b85d29c0b78636$export$d62fdc9d1b1cccad) {
            if (loopCount === -1) {
                // just started
                this._loopCount = 0;
                this._setEndings(true, true, false);
            }
            handle_stop: {
                if (time >= duration) time = duration;
                else if (time < 0) time = 0;
                else {
                    this.time = time;
                    break handle_stop;
                }
                if (this.clampWhenFinished) this.paused = true;
                else this.enabled = false;
                this.time = time;
                this._mixer.dispatchEvent({
                    type: 'finished',
                    action: this,
                    direction: deltaTime < 0 ? -1 : 1
                });
            }
        } else {
            if (loopCount === -1) {
                // just started
                if (deltaTime >= 0) {
                    loopCount = 0;
                    this._setEndings(true, this.repetitions === 0, pingPong);
                } else // when looping in reverse direction, the initial
                // transition through zero counts as a repetition,
                // so leave loopCount at -1
                this._setEndings(this.repetitions === 0, true, pingPong);
            }
            if (time >= duration || time < 0) {
                // wrap around
                const loopDelta = Math.floor(time / duration); // signed
                time -= duration * loopDelta;
                loopCount += Math.abs(loopDelta);
                const pending = this.repetitions - loopCount;
                if (pending <= 0) {
                    // have to stop (switch state, clamp time, fire event)
                    if (this.clampWhenFinished) this.paused = true;
                    else this.enabled = false;
                    time = deltaTime > 0 ? duration : 0;
                    this.time = time;
                    this._mixer.dispatchEvent({
                        type: 'finished',
                        action: this,
                        direction: deltaTime > 0 ? 1 : -1
                    });
                } else {
                    // keep running
                    if (pending === 1) {
                        // entering the last round
                        const atStart = deltaTime < 0;
                        this._setEndings(atStart, !atStart, pingPong);
                    } else this._setEndings(false, false, pingPong);
                    this._loopCount = loopCount;
                    this.time = time;
                    this._mixer.dispatchEvent({
                        type: 'loop',
                        action: this,
                        loopDelta: loopDelta
                    });
                }
            } else this.time = time;
            if (pingPong && (loopCount & 1) === 1) // invert time for the "pong round"
            return duration - time;
        }
        return time;
    }
    _setEndings(atStart, atEnd, pingPong) {
        const settings = this._interpolantSettings;
        if (pingPong) {
            settings.endingStart = $d5b85d29c0b78636$export$24a4ccb5099273b5;
            settings.endingEnd = $d5b85d29c0b78636$export$24a4ccb5099273b5;
        } else {
            // assuming for LoopOnce atStart == atEnd == true
            if (atStart) settings.endingStart = this.zeroSlopeAtStart ? $d5b85d29c0b78636$export$24a4ccb5099273b5 : $d5b85d29c0b78636$export$7f795934b84ab523;
            else settings.endingStart = $d5b85d29c0b78636$export$8e8c3ecdcd8e1fee;
            if (atEnd) settings.endingEnd = this.zeroSlopeAtEnd ? $d5b85d29c0b78636$export$24a4ccb5099273b5 : $d5b85d29c0b78636$export$7f795934b84ab523;
            else settings.endingEnd = $d5b85d29c0b78636$export$8e8c3ecdcd8e1fee;
        }
    }
    _scheduleFading(duration, weightNow, weightThen) {
        const mixer = this._mixer, now = mixer.time;
        let interpolant = this._weightInterpolant;
        if (interpolant === null) {
            interpolant = mixer._lendControlInterpolant();
            this._weightInterpolant = interpolant;
        }
        const times = interpolant.parameterPositions, values = interpolant.sampleValues;
        times[0] = now;
        values[0] = weightNow;
        times[1] = now + duration;
        values[1] = weightThen;
        return this;
    }
}
const $d5b85d29c0b78636$var$_controlInterpolantsResultBuffer = new Float32Array(1);
class $d5b85d29c0b78636$export$fbd77e5aefaa0102 extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(root){
        super();
        this._root = root;
        this._initMemoryManager();
        this._accuIndex = 0;
        this.time = 0;
        this.timeScale = 1.0;
    }
    _bindAction(action, prototypeAction) {
        const root = action._localRoot || this._root, tracks = action._clip.tracks, nTracks = tracks.length, bindings = action._propertyBindings, interpolants = action._interpolants, rootUuid = root.uuid, bindingsByRoot = this._bindingsByRootAndName;
        let bindingsByName = bindingsByRoot[rootUuid];
        if (bindingsByName === undefined) {
            bindingsByName = {};
            bindingsByRoot[rootUuid] = bindingsByName;
        }
        for(let i = 0; i !== nTracks; ++i){
            const track = tracks[i], trackName = track.name;
            let binding = bindingsByName[trackName];
            if (binding !== undefined) {
                ++binding.referenceCount;
                bindings[i] = binding;
            } else {
                binding = bindings[i];
                if (binding !== undefined) {
                    // existing binding, make sure the cache knows
                    if (binding._cacheIndex === null) {
                        ++binding.referenceCount;
                        this._addInactiveBinding(binding, rootUuid, trackName);
                    }
                    continue;
                }
                const path = prototypeAction && prototypeAction._propertyBindings[i].binding.parsedPath;
                binding = new $d5b85d29c0b78636$export$dfe0af1ca1acb78a($d5b85d29c0b78636$export$7bf70fcf9f891893.create(root, trackName, path), track.ValueTypeName, track.getValueSize());
                ++binding.referenceCount;
                this._addInactiveBinding(binding, rootUuid, trackName);
                bindings[i] = binding;
            }
            interpolants[i].resultBuffer = binding.buffer;
        }
    }
    _activateAction(action) {
        if (!this._isActiveAction(action)) {
            if (action._cacheIndex === null) {
                // this action has been forgotten by the cache, but the user
                // appears to be still using it -> rebind
                const rootUuid = (action._localRoot || this._root).uuid, clipUuid = action._clip.uuid, actionsForClip = this._actionsByClip[clipUuid];
                this._bindAction(action, actionsForClip && actionsForClip.knownActions[0]);
                this._addInactiveAction(action, clipUuid, rootUuid);
            }
            const bindings = action._propertyBindings;
            // increment reference counts / sort out state
            for(let i = 0, n = bindings.length; i !== n; ++i){
                const binding = bindings[i];
                if (binding.useCount++ === 0) {
                    this._lendBinding(binding);
                    binding.saveOriginalState();
                }
            }
            this._lendAction(action);
        }
    }
    _deactivateAction(action) {
        if (this._isActiveAction(action)) {
            const bindings = action._propertyBindings;
            // decrement reference counts / sort out state
            for(let i = 0, n = bindings.length; i !== n; ++i){
                const binding = bindings[i];
                if (--binding.useCount === 0) {
                    binding.restoreOriginalState();
                    this._takeBackBinding(binding);
                }
            }
            this._takeBackAction(action);
        }
    }
    // Memory manager
    _initMemoryManager() {
        this._actions = []; // 'nActiveActions' followed by inactive ones
        this._nActiveActions = 0;
        this._actionsByClip = {};
        // inside:
        // {
        // 	knownActions: Array< AnimationAction > - used as prototypes
        // 	actionByRoot: AnimationAction - lookup
        // }
        this._bindings = []; // 'nActiveBindings' followed by inactive ones
        this._nActiveBindings = 0;
        this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >
        this._controlInterpolants = []; // same game as above
        this._nActiveControlInterpolants = 0;
        const scope = this;
        this.stats = {
            actions: {
                get total () {
                    return scope._actions.length;
                },
                get inUse () {
                    return scope._nActiveActions;
                }
            },
            bindings: {
                get total () {
                    return scope._bindings.length;
                },
                get inUse () {
                    return scope._nActiveBindings;
                }
            },
            controlInterpolants: {
                get total () {
                    return scope._controlInterpolants.length;
                },
                get inUse () {
                    return scope._nActiveControlInterpolants;
                }
            }
        };
    }
    // Memory management for AnimationAction objects
    _isActiveAction(action) {
        const index = action._cacheIndex;
        return index !== null && index < this._nActiveActions;
    }
    _addInactiveAction(action, clipUuid, rootUuid) {
        const actions = this._actions, actionsByClip = this._actionsByClip;
        let actionsForClip = actionsByClip[clipUuid];
        if (actionsForClip === undefined) {
            actionsForClip = {
                knownActions: [
                    action
                ],
                actionByRoot: {}
            };
            action._byClipCacheIndex = 0;
            actionsByClip[clipUuid] = actionsForClip;
        } else {
            const knownActions = actionsForClip.knownActions;
            action._byClipCacheIndex = knownActions.length;
            knownActions.push(action);
        }
        action._cacheIndex = actions.length;
        actions.push(action);
        actionsForClip.actionByRoot[rootUuid] = action;
    }
    _removeInactiveAction(action) {
        const actions = this._actions, lastInactiveAction = actions[actions.length - 1], cacheIndex = action._cacheIndex;
        lastInactiveAction._cacheIndex = cacheIndex;
        actions[cacheIndex] = lastInactiveAction;
        actions.pop();
        action._cacheIndex = null;
        const clipUuid = action._clip.uuid, actionsByClip = this._actionsByClip, actionsForClip = actionsByClip[clipUuid], knownActionsForClip = actionsForClip.knownActions, lastKnownAction = knownActionsForClip[knownActionsForClip.length - 1], byClipCacheIndex = action._byClipCacheIndex;
        lastKnownAction._byClipCacheIndex = byClipCacheIndex;
        knownActionsForClip[byClipCacheIndex] = lastKnownAction;
        knownActionsForClip.pop();
        action._byClipCacheIndex = null;
        const actionByRoot = actionsForClip.actionByRoot, rootUuid = (action._localRoot || this._root).uuid;
        delete actionByRoot[rootUuid];
        if (knownActionsForClip.length === 0) delete actionsByClip[clipUuid];
        this._removeInactiveBindingsForAction(action);
    }
    _removeInactiveBindingsForAction(action) {
        const bindings = action._propertyBindings;
        for(let i = 0, n = bindings.length; i !== n; ++i){
            const binding = bindings[i];
            if (--binding.referenceCount === 0) this._removeInactiveBinding(binding);
        }
    }
    _lendAction(action) {
        // [ active actions |  inactive actions  ]
        // [  active actions >| inactive actions ]
        //                 s        a
        //                  <-swap->
        //                 a        s
        const actions = this._actions, prevIndex = action._cacheIndex, lastActiveIndex = this._nActiveActions++, firstInactiveAction = actions[lastActiveIndex];
        action._cacheIndex = lastActiveIndex;
        actions[lastActiveIndex] = action;
        firstInactiveAction._cacheIndex = prevIndex;
        actions[prevIndex] = firstInactiveAction;
    }
    _takeBackAction(action) {
        // [  active actions  | inactive actions ]
        // [ active actions |< inactive actions  ]
        //        a        s
        //         <-swap->
        //        s        a
        const actions = this._actions, prevIndex = action._cacheIndex, firstInactiveIndex = --this._nActiveActions, lastActiveAction = actions[firstInactiveIndex];
        action._cacheIndex = firstInactiveIndex;
        actions[firstInactiveIndex] = action;
        lastActiveAction._cacheIndex = prevIndex;
        actions[prevIndex] = lastActiveAction;
    }
    // Memory management for PropertyMixer objects
    _addInactiveBinding(binding, rootUuid, trackName) {
        const bindingsByRoot = this._bindingsByRootAndName, bindings = this._bindings;
        let bindingByName = bindingsByRoot[rootUuid];
        if (bindingByName === undefined) {
            bindingByName = {};
            bindingsByRoot[rootUuid] = bindingByName;
        }
        bindingByName[trackName] = binding;
        binding._cacheIndex = bindings.length;
        bindings.push(binding);
    }
    _removeInactiveBinding(binding) {
        const bindings = this._bindings, propBinding = binding.binding, rootUuid = propBinding.rootNode.uuid, trackName = propBinding.path, bindingsByRoot = this._bindingsByRootAndName, bindingByName = bindingsByRoot[rootUuid], lastInactiveBinding = bindings[bindings.length - 1], cacheIndex = binding._cacheIndex;
        lastInactiveBinding._cacheIndex = cacheIndex;
        bindings[cacheIndex] = lastInactiveBinding;
        bindings.pop();
        delete bindingByName[trackName];
        if (Object.keys(bindingByName).length === 0) delete bindingsByRoot[rootUuid];
    }
    _lendBinding(binding) {
        const bindings = this._bindings, prevIndex = binding._cacheIndex, lastActiveIndex = this._nActiveBindings++, firstInactiveBinding = bindings[lastActiveIndex];
        binding._cacheIndex = lastActiveIndex;
        bindings[lastActiveIndex] = binding;
        firstInactiveBinding._cacheIndex = prevIndex;
        bindings[prevIndex] = firstInactiveBinding;
    }
    _takeBackBinding(binding) {
        const bindings = this._bindings, prevIndex = binding._cacheIndex, firstInactiveIndex = --this._nActiveBindings, lastActiveBinding = bindings[firstInactiveIndex];
        binding._cacheIndex = firstInactiveIndex;
        bindings[firstInactiveIndex] = binding;
        lastActiveBinding._cacheIndex = prevIndex;
        bindings[prevIndex] = lastActiveBinding;
    }
    // Memory management of Interpolants for weight and time scale
    _lendControlInterpolant() {
        const interpolants = this._controlInterpolants, lastActiveIndex = this._nActiveControlInterpolants++;
        let interpolant = interpolants[lastActiveIndex];
        if (interpolant === undefined) {
            interpolant = new $d5b85d29c0b78636$export$a8e6009059f51e1a(new Float32Array(2), new Float32Array(2), 1, $d5b85d29c0b78636$var$_controlInterpolantsResultBuffer);
            interpolant.__cacheIndex = lastActiveIndex;
            interpolants[lastActiveIndex] = interpolant;
        }
        return interpolant;
    }
    _takeBackControlInterpolant(interpolant) {
        const interpolants = this._controlInterpolants, prevIndex = interpolant.__cacheIndex, firstInactiveIndex = --this._nActiveControlInterpolants, lastActiveInterpolant = interpolants[firstInactiveIndex];
        interpolant.__cacheIndex = firstInactiveIndex;
        interpolants[firstInactiveIndex] = interpolant;
        lastActiveInterpolant.__cacheIndex = prevIndex;
        interpolants[prevIndex] = lastActiveInterpolant;
    }
    // return an action for a clip optionally using a custom root target
    // object (this method allocates a lot of dynamic memory in case a
    // previously unknown clip/root combination is specified)
    clipAction(clip, optionalRoot, blendMode) {
        const root = optionalRoot || this._root, rootUuid = root.uuid;
        let clipObject = typeof clip === 'string' ? $d5b85d29c0b78636$export$d942c706bf23829c.findByName(root, clip) : clip;
        const clipUuid = clipObject !== null ? clipObject.uuid : clip;
        const actionsForClip = this._actionsByClip[clipUuid];
        let prototypeAction = null;
        if (blendMode === undefined) {
            if (clipObject !== null) blendMode = clipObject.blendMode;
            else blendMode = $d5b85d29c0b78636$export$bcfbbdcf8de7f8cd;
        }
        if (actionsForClip !== undefined) {
            const existingAction = actionsForClip.actionByRoot[rootUuid];
            if (existingAction !== undefined && existingAction.blendMode === blendMode) return existingAction;
            // we know the clip, so we don't have to parse all
            // the bindings again but can just copy
            prototypeAction = actionsForClip.knownActions[0];
            // also, take the clip from the prototype action
            if (clipObject === null) clipObject = prototypeAction._clip;
        }
        // clip must be known when specified via string
        if (clipObject === null) return null;
        // allocate all resources required to run it
        const newAction = new $d5b85d29c0b78636$export$6946940a69e799e(this, clipObject, optionalRoot, blendMode);
        this._bindAction(newAction, prototypeAction);
        // and make the action known to the memory manager
        this._addInactiveAction(newAction, clipUuid, rootUuid);
        return newAction;
    }
    // get an existing action
    existingAction(clip, optionalRoot) {
        const root = optionalRoot || this._root, rootUuid = root.uuid, clipObject = typeof clip === 'string' ? $d5b85d29c0b78636$export$d942c706bf23829c.findByName(root, clip) : clip, clipUuid = clipObject ? clipObject.uuid : clip, actionsForClip = this._actionsByClip[clipUuid];
        if (actionsForClip !== undefined) return actionsForClip.actionByRoot[rootUuid] || null;
        return null;
    }
    // deactivates all previously scheduled actions
    stopAllAction() {
        const actions = this._actions, nActions = this._nActiveActions;
        for(let i = nActions - 1; i >= 0; --i)actions[i].stop();
        return this;
    }
    // advance the time and update apply the animation
    update(deltaTime) {
        deltaTime *= this.timeScale;
        const actions = this._actions, nActions = this._nActiveActions, time = this.time += deltaTime, timeDirection = Math.sign(deltaTime), accuIndex = this._accuIndex ^= 1;
        // run active actions
        for(let i = 0; i !== nActions; ++i){
            const action = actions[i];
            action._update(time, deltaTime, timeDirection, accuIndex);
        }
        // update scene graph
        const bindings = this._bindings, nBindings = this._nActiveBindings;
        for(let i = 0; i !== nBindings; ++i)bindings[i].apply(accuIndex);
        return this;
    }
    // Allows you to seek to a specific time in an animation.
    setTime(timeInSeconds) {
        this.time = 0; // Zero out time attribute for AnimationMixer object;
        for(let i = 0; i < this._actions.length; i++)this._actions[i].time = 0; // Zero out time attribute for all associated AnimationAction objects.
        return this.update(timeInSeconds); // Update used to set exact time. Returns "this" AnimationMixer object.
    }
    // return this mixer's root target object
    getRoot() {
        return this._root;
    }
    // free all resources specific to a particular clip
    uncacheClip(clip) {
        const actions = this._actions, clipUuid = clip.uuid, actionsByClip = this._actionsByClip, actionsForClip = actionsByClip[clipUuid];
        if (actionsForClip !== undefined) {
            // note: just calling _removeInactiveAction would mess up the
            // iteration state and also require updating the state we can
            // just throw away
            const actionsToRemove = actionsForClip.knownActions;
            for(let i = 0, n = actionsToRemove.length; i !== n; ++i){
                const action = actionsToRemove[i];
                this._deactivateAction(action);
                const cacheIndex = action._cacheIndex, lastInactiveAction = actions[actions.length - 1];
                action._cacheIndex = null;
                action._byClipCacheIndex = null;
                lastInactiveAction._cacheIndex = cacheIndex;
                actions[cacheIndex] = lastInactiveAction;
                actions.pop();
                this._removeInactiveBindingsForAction(action);
            }
            delete actionsByClip[clipUuid];
        }
    }
    // free all resources specific to a particular root target object
    uncacheRoot(root) {
        const rootUuid = root.uuid, actionsByClip = this._actionsByClip;
        for(const clipUuid in actionsByClip){
            const actionByRoot = actionsByClip[clipUuid].actionByRoot, action = actionByRoot[rootUuid];
            if (action !== undefined) {
                this._deactivateAction(action);
                this._removeInactiveAction(action);
            }
        }
        const bindingsByRoot = this._bindingsByRootAndName, bindingByName = bindingsByRoot[rootUuid];
        if (bindingByName !== undefined) for(const trackName in bindingByName){
            const binding = bindingByName[trackName];
            binding.restoreOriginalState();
            this._removeInactiveBinding(binding);
        }
    }
    // remove a targeted clip from the cache
    uncacheAction(clip, optionalRoot) {
        const action = this.existingAction(clip, optionalRoot);
        if (action !== null) {
            this._deactivateAction(action);
            this._removeInactiveAction(action);
        }
    }
}
class $d5b85d29c0b78636$export$6b116d2fdfef087c extends $d5b85d29c0b78636$export$efcb1f8bf367cbfb {
    constructor(width = 1, height = 1, depth = 1, options = {}){
        super(width, height, options);
        this.isRenderTarget3D = true;
        this.depth = depth;
        this.texture = new $d5b85d29c0b78636$export$d7a3086320f856db(null, width, height, depth);
        this.texture.isRenderTargetTexture = true;
    }
}
class $d5b85d29c0b78636$export$eb4d196341728d65 extends $d5b85d29c0b78636$export$efcb1f8bf367cbfb {
    constructor(width = 1, height = 1, depth = 1, options = {}){
        super(width, height, options);
        this.isRenderTargetArray = true;
        this.depth = depth;
        this.texture = new $d5b85d29c0b78636$export$dfac6c8e811406a3(null, width, height, depth);
        this.texture.isRenderTargetTexture = true;
    }
}
class $d5b85d29c0b78636$export$2947cebfe91c02f8 {
    constructor(value){
        this.value = value;
    }
    clone() {
        return new $d5b85d29c0b78636$export$2947cebfe91c02f8(this.value.clone === undefined ? this.value : this.value.clone());
    }
}
let $d5b85d29c0b78636$var$_id = 0;
class $d5b85d29c0b78636$export$c412d5ffe1f79209 extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(){
        super();
        this.isUniformsGroup = true;
        Object.defineProperty(this, 'id', {
            value: $d5b85d29c0b78636$var$_id++
        });
        this.name = '';
        this.usage = $d5b85d29c0b78636$export$763e8360f4d7f77d;
        this.uniforms = [];
    }
    add(uniform) {
        this.uniforms.push(uniform);
        return this;
    }
    remove(uniform) {
        const index = this.uniforms.indexOf(uniform);
        if (index !== -1) this.uniforms.splice(index, 1);
        return this;
    }
    setName(name) {
        this.name = name;
        return this;
    }
    setUsage(value) {
        this.usage = value;
        return this;
    }
    dispose() {
        this.dispatchEvent({
            type: 'dispose'
        });
        return this;
    }
    copy(source) {
        this.name = source.name;
        this.usage = source.usage;
        const uniformsSource = source.uniforms;
        this.uniforms.length = 0;
        for(let i = 0, l = uniformsSource.length; i < l; i++){
            const uniforms = Array.isArray(uniformsSource[i]) ? uniformsSource[i] : [
                uniformsSource[i]
            ];
            for(let j = 0; j < uniforms.length; j++)this.uniforms.push(uniforms[j].clone());
        }
        return this;
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
class $d5b85d29c0b78636$export$25ec0e1af1389358 extends $d5b85d29c0b78636$export$3d5cd879f108f53f {
    constructor(array, stride, meshPerAttribute = 1){
        super(array, stride);
        this.isInstancedInterleavedBuffer = true;
        this.meshPerAttribute = meshPerAttribute;
    }
    copy(source) {
        super.copy(source);
        this.meshPerAttribute = source.meshPerAttribute;
        return this;
    }
    clone(data) {
        const ib = super.clone(data);
        ib.meshPerAttribute = this.meshPerAttribute;
        return ib;
    }
    toJSON(data) {
        const json = super.toJSON(data);
        json.isInstancedInterleavedBuffer = true;
        json.meshPerAttribute = this.meshPerAttribute;
        return json;
    }
}
class $d5b85d29c0b78636$export$6b7339ae8dbddf73 {
    constructor(buffer, type, itemSize, elementSize, count){
        this.isGLBufferAttribute = true;
        this.name = '';
        this.buffer = buffer;
        this.type = type;
        this.itemSize = itemSize;
        this.elementSize = elementSize;
        this.count = count;
        this.version = 0;
    }
    set needsUpdate(value) {
        if (value === true) this.version++;
    }
    setBuffer(buffer) {
        this.buffer = buffer;
        return this;
    }
    setType(type, elementSize) {
        this.type = type;
        this.elementSize = elementSize;
        return this;
    }
    setItemSize(itemSize) {
        this.itemSize = itemSize;
        return this;
    }
    setCount(count) {
        this.count = count;
        return this;
    }
}
const $d5b85d29c0b78636$var$_matrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
class $d5b85d29c0b78636$export$8b7aaceff00bd2f {
    constructor(origin, direction, near = 0, far = Infinity){
        this.ray = new $d5b85d29c0b78636$export$a186db52eed6d40e(origin, direction);
        // direction is assumed to be normalized (for accurate distance calculations)
        this.near = near;
        this.far = far;
        this.camera = null;
        this.layers = new $d5b85d29c0b78636$export$89312ce47c0ca777();
        this.params = {
            Mesh: {},
            Line: {
                threshold: 1
            },
            LOD: {},
            Points: {
                threshold: 1
            },
            Sprite: {}
        };
    }
    set(origin, direction) {
        // direction is assumed to be normalized (for accurate distance calculations)
        this.ray.set(origin, direction);
    }
    setFromCamera(coords, camera) {
        if (camera.isPerspectiveCamera) {
            this.ray.origin.setFromMatrixPosition(camera.matrixWorld);
            this.ray.direction.set(coords.x, coords.y, 0.5).unproject(camera).sub(this.ray.origin).normalize();
            this.camera = camera;
        } else if (camera.isOrthographicCamera) {
            this.ray.origin.set(coords.x, coords.y, (camera.near + camera.far) / (camera.near - camera.far)).unproject(camera); // set origin in plane of camera
            this.ray.direction.set(0, 0, -1).transformDirection(camera.matrixWorld);
            this.camera = camera;
        } else console.error('THREE.Raycaster: Unsupported camera type: ' + camera.type);
    }
    setFromXRController(controller) {
        $d5b85d29c0b78636$var$_matrix.identity().extractRotation(controller.matrixWorld);
        this.ray.origin.setFromMatrixPosition(controller.matrixWorld);
        this.ray.direction.set(0, 0, -1).applyMatrix4($d5b85d29c0b78636$var$_matrix);
        return this;
    }
    intersectObject(object, recursive = true, intersects = []) {
        $d5b85d29c0b78636$var$intersect(object, this, intersects, recursive);
        intersects.sort($d5b85d29c0b78636$var$ascSort);
        return intersects;
    }
    intersectObjects(objects, recursive = true, intersects = []) {
        for(let i = 0, l = objects.length; i < l; i++)$d5b85d29c0b78636$var$intersect(objects[i], this, intersects, recursive);
        intersects.sort($d5b85d29c0b78636$var$ascSort);
        return intersects;
    }
}
function $d5b85d29c0b78636$var$ascSort(a, b) {
    return a.distance - b.distance;
}
function $d5b85d29c0b78636$var$intersect(object, raycaster, intersects, recursive) {
    let propagate = true;
    if (object.layers.test(raycaster.layers)) {
        const result = object.raycast(raycaster, intersects);
        if (result === false) propagate = false;
    }
    if (propagate === true && recursive === true) {
        const children = object.children;
        for(let i = 0, l = children.length; i < l; i++)$d5b85d29c0b78636$var$intersect(children[i], raycaster, intersects, true);
    }
}
/**
 * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system
 *
 * phi (the polar angle) is measured from the positive y-axis. The positive y-axis is up.
 * theta (the azimuthal angle) is measured from the positive z-axis.
 */ class $d5b85d29c0b78636$export$d712cd887b4a00f7 {
    constructor(radius = 1, phi = 0, theta = 0){
        this.radius = radius;
        this.phi = phi; // polar angle
        this.theta = theta; // azimuthal angle
        return this;
    }
    set(radius, phi, theta) {
        this.radius = radius;
        this.phi = phi;
        this.theta = theta;
        return this;
    }
    copy(other) {
        this.radius = other.radius;
        this.phi = other.phi;
        this.theta = other.theta;
        return this;
    }
    // restrict phi to be between EPS and PI-EPS
    makeSafe() {
        const EPS = 0.000001;
        this.phi = $d5b85d29c0b78636$var$clamp(this.phi, EPS, Math.PI - EPS);
        return this;
    }
    setFromVector3(v) {
        return this.setFromCartesianCoords(v.x, v.y, v.z);
    }
    setFromCartesianCoords(x, y, z) {
        this.radius = Math.sqrt(x * x + y * y + z * z);
        if (this.radius === 0) {
            this.theta = 0;
            this.phi = 0;
        } else {
            this.theta = Math.atan2(x, z);
            this.phi = Math.acos($d5b85d29c0b78636$var$clamp(y / this.radius, -1, 1));
        }
        return this;
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
/**
 * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system
 */ class $d5b85d29c0b78636$export$287165bb2177f4fd {
    constructor(radius = 1, theta = 0, y = 0){
        this.radius = radius; // distance from the origin to a point in the x-z plane
        this.theta = theta; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis
        this.y = y; // height above the x-z plane
        return this;
    }
    set(radius, theta, y) {
        this.radius = radius;
        this.theta = theta;
        this.y = y;
        return this;
    }
    copy(other) {
        this.radius = other.radius;
        this.theta = other.theta;
        this.y = other.y;
        return this;
    }
    setFromVector3(v) {
        return this.setFromCartesianCoords(v.x, v.y, v.z);
    }
    setFromCartesianCoords(x, y, z) {
        this.radius = Math.sqrt(x * x + z * z);
        this.theta = Math.atan2(x, z);
        this.y = y;
        return this;
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
class $d5b85d29c0b78636$export$cbcc6560bf79fb38 {
    constructor(n11, n12, n21, n22){
        $d5b85d29c0b78636$export$cbcc6560bf79fb38.prototype.isMatrix2 = true;
        this.elements = [
            1,
            0,
            0,
            1
        ];
        if (n11 !== undefined) this.set(n11, n12, n21, n22);
    }
    identity() {
        this.set(1, 0, 0, 1);
        return this;
    }
    fromArray(array, offset = 0) {
        for(let i = 0; i < 4; i++)this.elements[i] = array[i + offset];
        return this;
    }
    set(n11, n12, n21, n22) {
        const te = this.elements;
        te[0] = n11;
        te[2] = n12;
        te[1] = n21;
        te[3] = n22;
        return this;
    }
}
const $d5b85d29c0b78636$var$_vector$4 = /*@__PURE__*/ new $d5b85d29c0b78636$export$c977b3e384af9ae1();
class $d5b85d29c0b78636$export$60f553fa130f08b0 {
    constructor(min = new $d5b85d29c0b78636$export$c977b3e384af9ae1(Infinity, Infinity), max = new $d5b85d29c0b78636$export$c977b3e384af9ae1(-Infinity, -Infinity)){
        this.isBox2 = true;
        this.min = min;
        this.max = max;
    }
    set(min, max) {
        this.min.copy(min);
        this.max.copy(max);
        return this;
    }
    setFromPoints(points) {
        this.makeEmpty();
        for(let i = 0, il = points.length; i < il; i++)this.expandByPoint(points[i]);
        return this;
    }
    setFromCenterAndSize(center, size) {
        const halfSize = $d5b85d29c0b78636$var$_vector$4.copy(size).multiplyScalar(0.5);
        this.min.copy(center).sub(halfSize);
        this.max.copy(center).add(halfSize);
        return this;
    }
    clone() {
        return new this.constructor().copy(this);
    }
    copy(box) {
        this.min.copy(box.min);
        this.max.copy(box.max);
        return this;
    }
    makeEmpty() {
        this.min.x = this.min.y = Infinity;
        this.max.x = this.max.y = -Infinity;
        return this;
    }
    isEmpty() {
        // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
        return this.max.x < this.min.x || this.max.y < this.min.y;
    }
    getCenter(target) {
        return this.isEmpty() ? target.set(0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5);
    }
    getSize(target) {
        return this.isEmpty() ? target.set(0, 0) : target.subVectors(this.max, this.min);
    }
    expandByPoint(point) {
        this.min.min(point);
        this.max.max(point);
        return this;
    }
    expandByVector(vector) {
        this.min.sub(vector);
        this.max.add(vector);
        return this;
    }
    expandByScalar(scalar) {
        this.min.addScalar(-scalar);
        this.max.addScalar(scalar);
        return this;
    }
    containsPoint(point) {
        return point.x >= this.min.x && point.x <= this.max.x && point.y >= this.min.y && point.y <= this.max.y;
    }
    containsBox(box) {
        return this.min.x <= box.min.x && box.max.x <= this.max.x && this.min.y <= box.min.y && box.max.y <= this.max.y;
    }
    getParameter(point, target) {
        // This can potentially have a divide by zero if the box
        // has a size dimension of 0.
        return target.set((point.x - this.min.x) / (this.max.x - this.min.x), (point.y - this.min.y) / (this.max.y - this.min.y));
    }
    intersectsBox(box) {
        // using 4 splitting planes to rule out intersections
        return box.max.x >= this.min.x && box.min.x <= this.max.x && box.max.y >= this.min.y && box.min.y <= this.max.y;
    }
    clampPoint(point, target) {
        return target.copy(point).clamp(this.min, this.max);
    }
    distanceToPoint(point) {
        return this.clampPoint(point, $d5b85d29c0b78636$var$_vector$4).distanceTo(point);
    }
    intersect(box) {
        this.min.max(box.min);
        this.max.min(box.max);
        if (this.isEmpty()) this.makeEmpty();
        return this;
    }
    union(box) {
        this.min.min(box.min);
        this.max.max(box.max);
        return this;
    }
    translate(offset) {
        this.min.add(offset);
        this.max.add(offset);
        return this;
    }
    equals(box) {
        return box.min.equals(this.min) && box.max.equals(this.max);
    }
}
const $d5b85d29c0b78636$var$_startP = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_startEnd = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$e0ba6359f1954fd3 {
    constructor(start = new $d5b85d29c0b78636$export$64b5c384219d3699(), end = new $d5b85d29c0b78636$export$64b5c384219d3699()){
        this.start = start;
        this.end = end;
    }
    set(start, end) {
        this.start.copy(start);
        this.end.copy(end);
        return this;
    }
    copy(line) {
        this.start.copy(line.start);
        this.end.copy(line.end);
        return this;
    }
    getCenter(target) {
        return target.addVectors(this.start, this.end).multiplyScalar(0.5);
    }
    delta(target) {
        return target.subVectors(this.end, this.start);
    }
    distanceSq() {
        return this.start.distanceToSquared(this.end);
    }
    distance() {
        return this.start.distanceTo(this.end);
    }
    at(t, target) {
        return this.delta(target).multiplyScalar(t).add(this.start);
    }
    closestPointToPointParameter(point, clampToLine) {
        $d5b85d29c0b78636$var$_startP.subVectors(point, this.start);
        $d5b85d29c0b78636$var$_startEnd.subVectors(this.end, this.start);
        const startEnd2 = $d5b85d29c0b78636$var$_startEnd.dot($d5b85d29c0b78636$var$_startEnd);
        const startEnd_startP = $d5b85d29c0b78636$var$_startEnd.dot($d5b85d29c0b78636$var$_startP);
        let t = startEnd_startP / startEnd2;
        if (clampToLine) t = $d5b85d29c0b78636$var$clamp(t, 0, 1);
        return t;
    }
    closestPointToPoint(point, clampToLine, target) {
        const t = this.closestPointToPointParameter(point, clampToLine);
        return this.delta(target).multiplyScalar(t).add(this.start);
    }
    applyMatrix4(matrix) {
        this.start.applyMatrix4(matrix);
        this.end.applyMatrix4(matrix);
        return this;
    }
    equals(line) {
        return line.start.equals(this.start) && line.end.equals(this.end);
    }
    clone() {
        return new this.constructor().copy(this);
    }
}
const $d5b85d29c0b78636$var$_vector$3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$4b14638ffdd81e68 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(light, color){
        super();
        this.light = light;
        this.matrixAutoUpdate = false;
        this.color = color;
        this.type = 'SpotLightHelper';
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        const positions = [
            0,
            0,
            0,
            0,
            0,
            1,
            0,
            0,
            0,
            1,
            0,
            1,
            0,
            0,
            0,
            -1,
            0,
            1,
            0,
            0,
            0,
            0,
            1,
            1,
            0,
            0,
            0,
            0,
            -1,
            1
        ];
        for(let i = 0, j = 1, l = 32; i < l; i++, j++){
            const p1 = i / l * Math.PI * 2;
            const p2 = j / l * Math.PI * 2;
            positions.push(Math.cos(p1), Math.sin(p1), 1, Math.cos(p2), Math.sin(p2), 1);
        }
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(positions, 3));
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            fog: false,
            toneMapped: false
        });
        this.cone = new $d5b85d29c0b78636$export$ff1ed10fedfdd604(geometry, material);
        this.add(this.cone);
        this.update();
    }
    dispose() {
        this.cone.geometry.dispose();
        this.cone.material.dispose();
    }
    update() {
        this.light.updateWorldMatrix(true, false);
        this.light.target.updateWorldMatrix(true, false);
        // update the local matrix based on the parent and light target transforms
        if (this.parent) {
            this.parent.updateWorldMatrix(true);
            this.matrix.copy(this.parent.matrixWorld).invert().multiply(this.light.matrixWorld);
        } else this.matrix.copy(this.light.matrixWorld);
        this.matrixWorld.copy(this.light.matrixWorld);
        const coneLength = this.light.distance ? this.light.distance : 1000;
        const coneWidth = coneLength * Math.tan(this.light.angle);
        this.cone.scale.set(coneWidth, coneWidth, coneLength);
        $d5b85d29c0b78636$var$_vector$3.setFromMatrixPosition(this.light.target.matrixWorld);
        this.cone.lookAt($d5b85d29c0b78636$var$_vector$3);
        if (this.color !== undefined) this.cone.material.color.set(this.color);
        else this.cone.material.color.copy(this.light.color);
    }
}
const $d5b85d29c0b78636$var$_vector$2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_boneMatrix = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
const $d5b85d29c0b78636$var$_matrixWorldInv = /*@__PURE__*/ new $d5b85d29c0b78636$export$2ae72fc923e5eb5();
class $d5b85d29c0b78636$export$5277df3c9e732259 extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(object){
        const bones = $d5b85d29c0b78636$var$getBoneList(object);
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        const vertices = [];
        const colors = [];
        const color1 = new $d5b85d29c0b78636$export$892596cec99bc70e(0, 0, 1);
        const color2 = new $d5b85d29c0b78636$export$892596cec99bc70e(0, 1, 0);
        for(let i = 0; i < bones.length; i++){
            const bone = bones[i];
            if (bone.parent && bone.parent.isBone) {
                vertices.push(0, 0, 0);
                vertices.push(0, 0, 0);
                colors.push(color1.r, color1.g, color1.b);
                colors.push(color2.r, color2.g, color2.b);
            }
        }
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        geometry.setAttribute('color', new $d5b85d29c0b78636$export$cbe7a62641830ebd(colors, 3));
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            vertexColors: true,
            depthTest: false,
            depthWrite: false,
            toneMapped: false,
            transparent: true
        });
        super(geometry, material);
        this.isSkeletonHelper = true;
        this.type = 'SkeletonHelper';
        this.root = object;
        this.bones = bones;
        this.matrix = object.matrixWorld;
        this.matrixAutoUpdate = false;
    }
    updateMatrixWorld(force) {
        const bones = this.bones;
        const geometry = this.geometry;
        const position = geometry.getAttribute('position');
        $d5b85d29c0b78636$var$_matrixWorldInv.copy(this.root.matrixWorld).invert();
        for(let i = 0, j = 0; i < bones.length; i++){
            const bone = bones[i];
            if (bone.parent && bone.parent.isBone) {
                $d5b85d29c0b78636$var$_boneMatrix.multiplyMatrices($d5b85d29c0b78636$var$_matrixWorldInv, bone.matrixWorld);
                $d5b85d29c0b78636$var$_vector$2.setFromMatrixPosition($d5b85d29c0b78636$var$_boneMatrix);
                position.setXYZ(j, $d5b85d29c0b78636$var$_vector$2.x, $d5b85d29c0b78636$var$_vector$2.y, $d5b85d29c0b78636$var$_vector$2.z);
                $d5b85d29c0b78636$var$_boneMatrix.multiplyMatrices($d5b85d29c0b78636$var$_matrixWorldInv, bone.parent.matrixWorld);
                $d5b85d29c0b78636$var$_vector$2.setFromMatrixPosition($d5b85d29c0b78636$var$_boneMatrix);
                position.setXYZ(j + 1, $d5b85d29c0b78636$var$_vector$2.x, $d5b85d29c0b78636$var$_vector$2.y, $d5b85d29c0b78636$var$_vector$2.z);
                j += 2;
            }
        }
        geometry.getAttribute('position').needsUpdate = true;
        super.updateMatrixWorld(force);
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
function $d5b85d29c0b78636$var$getBoneList(object) {
    const boneList = [];
    if (object.isBone === true) boneList.push(object);
    for(let i = 0; i < object.children.length; i++)boneList.push.apply(boneList, $d5b85d29c0b78636$var$getBoneList(object.children[i]));
    return boneList;
}
class $d5b85d29c0b78636$export$9a9291685b9e4023 extends $d5b85d29c0b78636$export$e176487c05830cc5 {
    constructor(light, sphereSize, color){
        const geometry = new $d5b85d29c0b78636$export$1b417fc3b307a251(sphereSize, 4, 2);
        const material = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
            wireframe: true,
            fog: false,
            toneMapped: false
        });
        super(geometry, material);
        this.light = light;
        this.color = color;
        this.type = 'PointLightHelper';
        this.matrix = this.light.matrixWorld;
        this.matrixAutoUpdate = false;
        this.update();
    /*
	// TODO: delete this comment?
	const distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );
	const distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );

	this.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );
	this.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );

	const d = light.distance;

	if ( d === 0.0 ) {

		this.lightDistance.visible = false;

	} else {

		this.lightDistance.scale.set( d, d, d );

	}

	this.add( this.lightDistance );
	*/ }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
    update() {
        this.light.updateWorldMatrix(true, false);
        if (this.color !== undefined) this.material.color.set(this.color);
        else this.material.color.copy(this.light.color);
    /*
		const d = this.light.distance;

		if ( d === 0.0 ) {

			this.lightDistance.visible = false;

		} else {

			this.lightDistance.visible = true;
			this.lightDistance.scale.set( d, d, d );

		}
		*/ }
}
const $d5b85d29c0b78636$var$_vector$1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_color1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$892596cec99bc70e();
const $d5b85d29c0b78636$var$_color2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$892596cec99bc70e();
class $d5b85d29c0b78636$export$8dca15f13f4f8172 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(light, size, color){
        super();
        this.light = light;
        this.matrix = light.matrixWorld;
        this.matrixAutoUpdate = false;
        this.color = color;
        this.type = 'HemisphereLightHelper';
        const geometry = new $d5b85d29c0b78636$export$1954e2b809fe361e(size);
        geometry.rotateY(Math.PI * 0.5);
        this.material = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
            wireframe: true,
            fog: false,
            toneMapped: false
        });
        if (this.color === undefined) this.material.vertexColors = true;
        const position = geometry.getAttribute('position');
        const colors = new Float32Array(position.count * 3);
        geometry.setAttribute('color', new $d5b85d29c0b78636$export$8dea267bd6bde117(colors, 3));
        this.add(new $d5b85d29c0b78636$export$e176487c05830cc5(geometry, this.material));
        this.update();
    }
    dispose() {
        this.children[0].geometry.dispose();
        this.children[0].material.dispose();
    }
    update() {
        const mesh = this.children[0];
        if (this.color !== undefined) this.material.color.set(this.color);
        else {
            const colors = mesh.geometry.getAttribute('color');
            $d5b85d29c0b78636$var$_color1.copy(this.light.color);
            $d5b85d29c0b78636$var$_color2.copy(this.light.groundColor);
            for(let i = 0, l = colors.count; i < l; i++){
                const color = i < l / 2 ? $d5b85d29c0b78636$var$_color1 : $d5b85d29c0b78636$var$_color2;
                colors.setXYZ(i, color.r, color.g, color.b);
            }
            colors.needsUpdate = true;
        }
        this.light.updateWorldMatrix(true, false);
        mesh.lookAt($d5b85d29c0b78636$var$_vector$1.setFromMatrixPosition(this.light.matrixWorld).negate());
    }
}
class $d5b85d29c0b78636$export$3875d39926561055 extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(size = 10, divisions = 10, color1 = 0x444444, color2 = 0x888888){
        color1 = new $d5b85d29c0b78636$export$892596cec99bc70e(color1);
        color2 = new $d5b85d29c0b78636$export$892596cec99bc70e(color2);
        const center = divisions / 2;
        const step = size / divisions;
        const halfSize = size / 2;
        const vertices = [], colors = [];
        for(let i = 0, j = 0, k = -halfSize; i <= divisions; i++, k += step){
            vertices.push(-halfSize, 0, k, halfSize, 0, k);
            vertices.push(k, 0, -halfSize, k, 0, halfSize);
            const color = i === center ? color1 : color2;
            color.toArray(colors, j);
            j += 3;
            color.toArray(colors, j);
            j += 3;
            color.toArray(colors, j);
            j += 3;
            color.toArray(colors, j);
            j += 3;
        }
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        geometry.setAttribute('color', new $d5b85d29c0b78636$export$cbe7a62641830ebd(colors, 3));
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            vertexColors: true,
            toneMapped: false
        });
        super(geometry, material);
        this.type = 'GridHelper';
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
class $d5b85d29c0b78636$export$361430a10f533cd3 extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(radius = 10, sectors = 16, rings = 8, divisions = 64, color1 = 0x444444, color2 = 0x888888){
        color1 = new $d5b85d29c0b78636$export$892596cec99bc70e(color1);
        color2 = new $d5b85d29c0b78636$export$892596cec99bc70e(color2);
        const vertices = [];
        const colors = [];
        // create the sectors
        if (sectors > 1) for(let i = 0; i < sectors; i++){
            const v = i / sectors * (Math.PI * 2);
            const x = Math.sin(v) * radius;
            const z = Math.cos(v) * radius;
            vertices.push(0, 0, 0);
            vertices.push(x, 0, z);
            const color = i & 1 ? color1 : color2;
            colors.push(color.r, color.g, color.b);
            colors.push(color.r, color.g, color.b);
        }
        // create the rings
        for(let i = 0; i < rings; i++){
            const color = i & 1 ? color1 : color2;
            const r = radius - radius / rings * i;
            for(let j = 0; j < divisions; j++){
                // first vertex
                let v = j / divisions * (Math.PI * 2);
                let x = Math.sin(v) * r;
                let z = Math.cos(v) * r;
                vertices.push(x, 0, z);
                colors.push(color.r, color.g, color.b);
                // second vertex
                v = (j + 1) / divisions * (Math.PI * 2);
                x = Math.sin(v) * r;
                z = Math.cos(v) * r;
                vertices.push(x, 0, z);
                colors.push(color.r, color.g, color.b);
            }
        }
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        geometry.setAttribute('color', new $d5b85d29c0b78636$export$cbe7a62641830ebd(colors, 3));
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            vertexColors: true,
            toneMapped: false
        });
        super(geometry, material);
        this.type = 'PolarGridHelper';
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
const $d5b85d29c0b78636$var$_v1 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v2 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_v3 = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
class $d5b85d29c0b78636$export$f8e434dc14203e7d extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    constructor(light, size, color){
        super();
        this.light = light;
        this.matrix = light.matrixWorld;
        this.matrixAutoUpdate = false;
        this.color = color;
        this.type = 'DirectionalLightHelper';
        if (size === undefined) size = 1;
        let geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd([
            -size,
            size,
            0,
            size,
            size,
            0,
            size,
            -size,
            0,
            -size,
            -size,
            0,
            -size,
            size,
            0
        ], 3));
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            fog: false,
            toneMapped: false
        });
        this.lightPlane = new $d5b85d29c0b78636$export$17d680238e50603e(geometry, material);
        this.add(this.lightPlane);
        geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd([
            0,
            0,
            0,
            0,
            0,
            1
        ], 3));
        this.targetLine = new $d5b85d29c0b78636$export$17d680238e50603e(geometry, material);
        this.add(this.targetLine);
        this.update();
    }
    dispose() {
        this.lightPlane.geometry.dispose();
        this.lightPlane.material.dispose();
        this.targetLine.geometry.dispose();
        this.targetLine.material.dispose();
    }
    update() {
        this.light.updateWorldMatrix(true, false);
        this.light.target.updateWorldMatrix(true, false);
        $d5b85d29c0b78636$var$_v1.setFromMatrixPosition(this.light.matrixWorld);
        $d5b85d29c0b78636$var$_v2.setFromMatrixPosition(this.light.target.matrixWorld);
        $d5b85d29c0b78636$var$_v3.subVectors($d5b85d29c0b78636$var$_v2, $d5b85d29c0b78636$var$_v1);
        this.lightPlane.lookAt($d5b85d29c0b78636$var$_v2);
        if (this.color !== undefined) {
            this.lightPlane.material.color.set(this.color);
            this.targetLine.material.color.set(this.color);
        } else {
            this.lightPlane.material.color.copy(this.light.color);
            this.targetLine.material.color.copy(this.light.color);
        }
        this.targetLine.lookAt($d5b85d29c0b78636$var$_v2);
        this.targetLine.scale.z = $d5b85d29c0b78636$var$_v3.length();
    }
}
const $d5b85d29c0b78636$var$_vector = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
const $d5b85d29c0b78636$var$_camera = /*@__PURE__*/ new $d5b85d29c0b78636$export$79f141de891a5fed();
/**
 *	- shows frustum, line of sight and up of the camera
 *	- suitable for fast updates
 * 	- based on frustum visualization in lightgl.js shadowmap example
 *		https://github.com/evanw/lightgl.js/blob/master/tests/shadowmap.html
 */ class $d5b85d29c0b78636$export$ed8e93f853cd795 extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(camera){
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            color: 0xffffff,
            vertexColors: true,
            toneMapped: false
        });
        const vertices = [];
        const colors = [];
        const pointMap = {};
        // near
        addLine('n1', 'n2');
        addLine('n2', 'n4');
        addLine('n4', 'n3');
        addLine('n3', 'n1');
        // far
        addLine('f1', 'f2');
        addLine('f2', 'f4');
        addLine('f4', 'f3');
        addLine('f3', 'f1');
        // sides
        addLine('n1', 'f1');
        addLine('n2', 'f2');
        addLine('n3', 'f3');
        addLine('n4', 'f4');
        // cone
        addLine('p', 'n1');
        addLine('p', 'n2');
        addLine('p', 'n3');
        addLine('p', 'n4');
        // up
        addLine('u1', 'u2');
        addLine('u2', 'u3');
        addLine('u3', 'u1');
        // target
        addLine('c', 't');
        addLine('p', 'c');
        // cross
        addLine('cn1', 'cn2');
        addLine('cn3', 'cn4');
        addLine('cf1', 'cf2');
        addLine('cf3', 'cf4');
        function addLine(a, b) {
            addPoint(a);
            addPoint(b);
        }
        function addPoint(id) {
            vertices.push(0, 0, 0);
            colors.push(0, 0, 0);
            if (pointMap[id] === undefined) pointMap[id] = [];
            pointMap[id].push(vertices.length / 3 - 1);
        }
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        geometry.setAttribute('color', new $d5b85d29c0b78636$export$cbe7a62641830ebd(colors, 3));
        super(geometry, material);
        this.type = 'CameraHelper';
        this.camera = camera;
        if (this.camera.updateProjectionMatrix) this.camera.updateProjectionMatrix();
        this.matrix = camera.matrixWorld;
        this.matrixAutoUpdate = false;
        this.pointMap = pointMap;
        this.update();
        // colors
        const colorFrustum = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffaa00);
        const colorCone = new $d5b85d29c0b78636$export$892596cec99bc70e(0xff0000);
        const colorUp = new $d5b85d29c0b78636$export$892596cec99bc70e(0x00aaff);
        const colorTarget = new $d5b85d29c0b78636$export$892596cec99bc70e(0xffffff);
        const colorCross = new $d5b85d29c0b78636$export$892596cec99bc70e(0x333333);
        this.setColors(colorFrustum, colorCone, colorUp, colorTarget, colorCross);
    }
    setColors(frustum, cone, up, target, cross) {
        const geometry = this.geometry;
        const colorAttribute = geometry.getAttribute('color');
        // near
        colorAttribute.setXYZ(0, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(1, frustum.r, frustum.g, frustum.b); // n1, n2
        colorAttribute.setXYZ(2, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(3, frustum.r, frustum.g, frustum.b); // n2, n4
        colorAttribute.setXYZ(4, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(5, frustum.r, frustum.g, frustum.b); // n4, n3
        colorAttribute.setXYZ(6, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(7, frustum.r, frustum.g, frustum.b); // n3, n1
        // far
        colorAttribute.setXYZ(8, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(9, frustum.r, frustum.g, frustum.b); // f1, f2
        colorAttribute.setXYZ(10, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(11, frustum.r, frustum.g, frustum.b); // f2, f4
        colorAttribute.setXYZ(12, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(13, frustum.r, frustum.g, frustum.b); // f4, f3
        colorAttribute.setXYZ(14, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(15, frustum.r, frustum.g, frustum.b); // f3, f1
        // sides
        colorAttribute.setXYZ(16, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(17, frustum.r, frustum.g, frustum.b); // n1, f1
        colorAttribute.setXYZ(18, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(19, frustum.r, frustum.g, frustum.b); // n2, f2
        colorAttribute.setXYZ(20, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(21, frustum.r, frustum.g, frustum.b); // n3, f3
        colorAttribute.setXYZ(22, frustum.r, frustum.g, frustum.b);
        colorAttribute.setXYZ(23, frustum.r, frustum.g, frustum.b); // n4, f4
        // cone
        colorAttribute.setXYZ(24, cone.r, cone.g, cone.b);
        colorAttribute.setXYZ(25, cone.r, cone.g, cone.b); // p, n1
        colorAttribute.setXYZ(26, cone.r, cone.g, cone.b);
        colorAttribute.setXYZ(27, cone.r, cone.g, cone.b); // p, n2
        colorAttribute.setXYZ(28, cone.r, cone.g, cone.b);
        colorAttribute.setXYZ(29, cone.r, cone.g, cone.b); // p, n3
        colorAttribute.setXYZ(30, cone.r, cone.g, cone.b);
        colorAttribute.setXYZ(31, cone.r, cone.g, cone.b); // p, n4
        // up
        colorAttribute.setXYZ(32, up.r, up.g, up.b);
        colorAttribute.setXYZ(33, up.r, up.g, up.b); // u1, u2
        colorAttribute.setXYZ(34, up.r, up.g, up.b);
        colorAttribute.setXYZ(35, up.r, up.g, up.b); // u2, u3
        colorAttribute.setXYZ(36, up.r, up.g, up.b);
        colorAttribute.setXYZ(37, up.r, up.g, up.b); // u3, u1
        // target
        colorAttribute.setXYZ(38, target.r, target.g, target.b);
        colorAttribute.setXYZ(39, target.r, target.g, target.b); // c, t
        colorAttribute.setXYZ(40, cross.r, cross.g, cross.b);
        colorAttribute.setXYZ(41, cross.r, cross.g, cross.b); // p, c
        // cross
        colorAttribute.setXYZ(42, cross.r, cross.g, cross.b);
        colorAttribute.setXYZ(43, cross.r, cross.g, cross.b); // cn1, cn2
        colorAttribute.setXYZ(44, cross.r, cross.g, cross.b);
        colorAttribute.setXYZ(45, cross.r, cross.g, cross.b); // cn3, cn4
        colorAttribute.setXYZ(46, cross.r, cross.g, cross.b);
        colorAttribute.setXYZ(47, cross.r, cross.g, cross.b); // cf1, cf2
        colorAttribute.setXYZ(48, cross.r, cross.g, cross.b);
        colorAttribute.setXYZ(49, cross.r, cross.g, cross.b); // cf3, cf4
        colorAttribute.needsUpdate = true;
    }
    update() {
        const geometry = this.geometry;
        const pointMap = this.pointMap;
        const w = 1, h = 1;
        // we need just camera projection matrix inverse
        // world matrix must be identity
        $d5b85d29c0b78636$var$_camera.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse);
        // Adjust z values based on coordinate system
        const nearZ = this.camera.coordinateSystem === $d5b85d29c0b78636$export$5a0e9190d10875d3 ? -1 : 0;
        // center / target
        $d5b85d29c0b78636$var$setPoint('c', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, 0, nearZ);
        $d5b85d29c0b78636$var$setPoint('t', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, 0, 1);
        // near
        $d5b85d29c0b78636$var$setPoint('n1', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w, -h, nearZ);
        $d5b85d29c0b78636$var$setPoint('n2', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w, -h, nearZ);
        $d5b85d29c0b78636$var$setPoint('n3', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w, h, nearZ);
        $d5b85d29c0b78636$var$setPoint('n4', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w, h, nearZ);
        // far
        $d5b85d29c0b78636$var$setPoint('f1', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w, -h, 1);
        $d5b85d29c0b78636$var$setPoint('f2', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w, -h, 1);
        $d5b85d29c0b78636$var$setPoint('f3', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w, h, 1);
        $d5b85d29c0b78636$var$setPoint('f4', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w, h, 1);
        // up
        $d5b85d29c0b78636$var$setPoint('u1', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w * 0.7, h * 1.1, nearZ);
        $d5b85d29c0b78636$var$setPoint('u2', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w * 0.7, h * 1.1, nearZ);
        $d5b85d29c0b78636$var$setPoint('u3', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, h * 2, nearZ);
        // cross
        $d5b85d29c0b78636$var$setPoint('cf1', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w, 0, 1);
        $d5b85d29c0b78636$var$setPoint('cf2', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w, 0, 1);
        $d5b85d29c0b78636$var$setPoint('cf3', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, -h, 1);
        $d5b85d29c0b78636$var$setPoint('cf4', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, h, 1);
        $d5b85d29c0b78636$var$setPoint('cn1', pointMap, geometry, $d5b85d29c0b78636$var$_camera, -w, 0, nearZ);
        $d5b85d29c0b78636$var$setPoint('cn2', pointMap, geometry, $d5b85d29c0b78636$var$_camera, w, 0, nearZ);
        $d5b85d29c0b78636$var$setPoint('cn3', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, -h, nearZ);
        $d5b85d29c0b78636$var$setPoint('cn4', pointMap, geometry, $d5b85d29c0b78636$var$_camera, 0, h, nearZ);
        geometry.getAttribute('position').needsUpdate = true;
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
function $d5b85d29c0b78636$var$setPoint(point, pointMap, geometry, camera, x, y, z) {
    $d5b85d29c0b78636$var$_vector.set(x, y, z).unproject(camera);
    const points = pointMap[point];
    if (points !== undefined) {
        const position = geometry.getAttribute('position');
        for(let i = 0, l = points.length; i < l; i++)position.setXYZ(points[i], $d5b85d29c0b78636$var$_vector.x, $d5b85d29c0b78636$var$_vector.y, $d5b85d29c0b78636$var$_vector.z);
    }
}
const $d5b85d29c0b78636$var$_box = /*@__PURE__*/ new $d5b85d29c0b78636$export$6f7d5a9418ab2aa3();
class $d5b85d29c0b78636$export$38a664cc862a6a9d extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(object, color = 0xffff00){
        const indices = new Uint16Array([
            0,
            1,
            1,
            2,
            2,
            3,
            3,
            0,
            4,
            5,
            5,
            6,
            6,
            7,
            7,
            4,
            0,
            4,
            1,
            5,
            2,
            6,
            3,
            7
        ]);
        const positions = new Float32Array(24);
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setIndex(new $d5b85d29c0b78636$export$8dea267bd6bde117(indices, 1));
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$8dea267bd6bde117(positions, 3));
        super(geometry, new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            color: color,
            toneMapped: false
        }));
        this.object = object;
        this.type = 'BoxHelper';
        this.matrixAutoUpdate = false;
        this.update();
    }
    update(object) {
        if (object !== undefined) console.warn('THREE.BoxHelper: .update() has no longer arguments.');
        if (this.object !== undefined) $d5b85d29c0b78636$var$_box.setFromObject(this.object);
        if ($d5b85d29c0b78636$var$_box.isEmpty()) return;
        const min = $d5b85d29c0b78636$var$_box.min;
        const max = $d5b85d29c0b78636$var$_box.max;
        /*
			5____4
		1/___0/|
		| 6__|_7
		2/___3/

		0: max.x, max.y, max.z
		1: min.x, max.y, max.z
		2: min.x, min.y, max.z
		3: max.x, min.y, max.z
		4: max.x, max.y, min.z
		5: min.x, max.y, min.z
		6: min.x, min.y, min.z
		7: max.x, min.y, min.z
		*/ const position = this.geometry.attributes.position;
        const array = position.array;
        array[0] = max.x;
        array[1] = max.y;
        array[2] = max.z;
        array[3] = min.x;
        array[4] = max.y;
        array[5] = max.z;
        array[6] = min.x;
        array[7] = min.y;
        array[8] = max.z;
        array[9] = max.x;
        array[10] = min.y;
        array[11] = max.z;
        array[12] = max.x;
        array[13] = max.y;
        array[14] = min.z;
        array[15] = min.x;
        array[16] = max.y;
        array[17] = min.z;
        array[18] = min.x;
        array[19] = min.y;
        array[20] = min.z;
        array[21] = max.x;
        array[22] = min.y;
        array[23] = min.z;
        position.needsUpdate = true;
        this.geometry.computeBoundingSphere();
    }
    setFromObject(object) {
        this.object = object;
        this.update();
        return this;
    }
    copy(source, recursive) {
        super.copy(source, recursive);
        this.object = source.object;
        return this;
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
class $d5b85d29c0b78636$export$ce39f4bb96c9a290 extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(box, color = 0xffff00){
        const indices = new Uint16Array([
            0,
            1,
            1,
            2,
            2,
            3,
            3,
            0,
            4,
            5,
            5,
            6,
            6,
            7,
            7,
            4,
            0,
            4,
            1,
            5,
            2,
            6,
            3,
            7
        ]);
        const positions = [
            1,
            1,
            1,
            -1,
            1,
            1,
            -1,
            -1,
            1,
            1,
            -1,
            1,
            1,
            1,
            -1,
            -1,
            1,
            -1,
            -1,
            -1,
            -1,
            1,
            -1,
            -1
        ];
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setIndex(new $d5b85d29c0b78636$export$8dea267bd6bde117(indices, 1));
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(positions, 3));
        super(geometry, new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            color: color,
            toneMapped: false
        }));
        this.box = box;
        this.type = 'Box3Helper';
        this.geometry.computeBoundingSphere();
    }
    updateMatrixWorld(force) {
        const box = this.box;
        if (box.isEmpty()) return;
        box.getCenter(this.position);
        box.getSize(this.scale);
        this.scale.multiplyScalar(0.5);
        super.updateMatrixWorld(force);
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
class $d5b85d29c0b78636$export$a34fe8156c66e5d7 extends $d5b85d29c0b78636$export$17d680238e50603e {
    constructor(plane, size = 1, hex = 0xffff00){
        const color = hex;
        const positions = [
            1,
            -1,
            0,
            -1,
            1,
            0,
            -1,
            -1,
            0,
            1,
            1,
            0,
            -1,
            1,
            0,
            -1,
            -1,
            0,
            1,
            -1,
            0,
            1,
            1,
            0
        ];
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(positions, 3));
        geometry.computeBoundingSphere();
        super(geometry, new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            color: color,
            toneMapped: false
        }));
        this.type = 'PlaneHelper';
        this.plane = plane;
        this.size = size;
        const positions2 = [
            1,
            1,
            0,
            -1,
            1,
            0,
            -1,
            -1,
            0,
            1,
            1,
            0,
            -1,
            -1,
            0,
            1,
            -1,
            0
        ];
        const geometry2 = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry2.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(positions2, 3));
        geometry2.computeBoundingSphere();
        this.add(new $d5b85d29c0b78636$export$e176487c05830cc5(geometry2, new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
            color: color,
            opacity: 0.2,
            transparent: true,
            depthWrite: false,
            toneMapped: false
        })));
    }
    updateMatrixWorld(force) {
        this.position.set(0, 0, 0);
        this.scale.set(0.5 * this.size, 0.5 * this.size, 1);
        this.lookAt(this.plane.normal);
        this.translateZ(-this.plane.constant);
        super.updateMatrixWorld(force);
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
        this.children[0].geometry.dispose();
        this.children[0].material.dispose();
    }
}
const $d5b85d29c0b78636$var$_axis = /*@__PURE__*/ new $d5b85d29c0b78636$export$64b5c384219d3699();
let $d5b85d29c0b78636$var$_lineGeometry, $d5b85d29c0b78636$var$_coneGeometry;
class $d5b85d29c0b78636$export$a3008e7bd8d2cbe7 extends $d5b85d29c0b78636$export$e4dd07dff30cc924 {
    // dir is assumed to be normalized
    constructor(dir = new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, 1), origin = new $d5b85d29c0b78636$export$64b5c384219d3699(0, 0, 0), length = 1, color = 0xffff00, headLength = length * 0.2, headWidth = headLength * 0.2){
        super();
        this.type = 'ArrowHelper';
        if ($d5b85d29c0b78636$var$_lineGeometry === undefined) {
            $d5b85d29c0b78636$var$_lineGeometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
            $d5b85d29c0b78636$var$_lineGeometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd([
                0,
                0,
                0,
                0,
                1,
                0
            ], 3));
            $d5b85d29c0b78636$var$_coneGeometry = new $d5b85d29c0b78636$export$68f745719dbe5198(0, 0.5, 1, 5, 1);
            $d5b85d29c0b78636$var$_coneGeometry.translate(0, -0.5, 0);
        }
        this.position.copy(origin);
        this.line = new $d5b85d29c0b78636$export$17d680238e50603e($d5b85d29c0b78636$var$_lineGeometry, new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            color: color,
            toneMapped: false
        }));
        this.line.matrixAutoUpdate = false;
        this.add(this.line);
        this.cone = new $d5b85d29c0b78636$export$e176487c05830cc5($d5b85d29c0b78636$var$_coneGeometry, new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
            color: color,
            toneMapped: false
        }));
        this.cone.matrixAutoUpdate = false;
        this.add(this.cone);
        this.setDirection(dir);
        this.setLength(length, headLength, headWidth);
    }
    setDirection(dir) {
        // dir is assumed to be normalized
        if (dir.y > 0.99999) this.quaternion.set(0, 0, 0, 1);
        else if (dir.y < -0.99999) this.quaternion.set(1, 0, 0, 0);
        else {
            $d5b85d29c0b78636$var$_axis.set(dir.z, 0, -dir.x).normalize();
            const radians = Math.acos(dir.y);
            this.quaternion.setFromAxisAngle($d5b85d29c0b78636$var$_axis, radians);
        }
    }
    setLength(length, headLength = length * 0.2, headWidth = headLength * 0.2) {
        this.line.scale.set(1, Math.max(0.0001, length - headLength), 1); // see #17458
        this.line.updateMatrix();
        this.cone.scale.set(headWidth, headLength, headWidth);
        this.cone.position.y = length;
        this.cone.updateMatrix();
    }
    setColor(color) {
        this.line.material.color.set(color);
        this.cone.material.color.set(color);
    }
    copy(source) {
        super.copy(source, false);
        this.line.copy(source.line);
        this.cone.copy(source.cone);
        return this;
    }
    dispose() {
        this.line.geometry.dispose();
        this.line.material.dispose();
        this.cone.geometry.dispose();
        this.cone.material.dispose();
    }
}
class $d5b85d29c0b78636$export$6c8303f35b8578fd extends $d5b85d29c0b78636$export$ff1ed10fedfdd604 {
    constructor(size = 1){
        const vertices = [
            0,
            0,
            0,
            size,
            0,
            0,
            0,
            0,
            0,
            0,
            size,
            0,
            0,
            0,
            0,
            0,
            0,
            size
        ];
        const colors = [
            1,
            0,
            0,
            1,
            0.6,
            0,
            0,
            1,
            0,
            0.6,
            1,
            0,
            0,
            0,
            1,
            0,
            0.6,
            1
        ];
        const geometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        geometry.setAttribute('position', new $d5b85d29c0b78636$export$cbe7a62641830ebd(vertices, 3));
        geometry.setAttribute('color', new $d5b85d29c0b78636$export$cbe7a62641830ebd(colors, 3));
        const material = new $d5b85d29c0b78636$export$fbaaa33907730a0c({
            vertexColors: true,
            toneMapped: false
        });
        super(geometry, material);
        this.type = 'AxesHelper';
    }
    setColors(xAxisColor, yAxisColor, zAxisColor) {
        const color = new $d5b85d29c0b78636$export$892596cec99bc70e();
        const array = this.geometry.attributes.color.array;
        color.set(xAxisColor);
        color.toArray(array, 0);
        color.toArray(array, 3);
        color.set(yAxisColor);
        color.toArray(array, 6);
        color.toArray(array, 9);
        color.set(zAxisColor);
        color.toArray(array, 12);
        color.toArray(array, 15);
        this.geometry.attributes.color.needsUpdate = true;
        return this;
    }
    dispose() {
        this.geometry.dispose();
        this.material.dispose();
    }
}
class $d5b85d29c0b78636$export$148534a3c727230b {
    constructor(){
        this.type = 'ShapePath';
        this.color = new $d5b85d29c0b78636$export$892596cec99bc70e();
        this.subPaths = [];
        this.currentPath = null;
    }
    moveTo(x, y) {
        this.currentPath = new $d5b85d29c0b78636$export$4b2950bdac9b6ee9();
        this.subPaths.push(this.currentPath);
        this.currentPath.moveTo(x, y);
        return this;
    }
    lineTo(x, y) {
        this.currentPath.lineTo(x, y);
        return this;
    }
    quadraticCurveTo(aCPx, aCPy, aX, aY) {
        this.currentPath.quadraticCurveTo(aCPx, aCPy, aX, aY);
        return this;
    }
    bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
        this.currentPath.bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY);
        return this;
    }
    splineThru(pts) {
        this.currentPath.splineThru(pts);
        return this;
    }
    toShapes(isCCW) {
        function toShapesNoHoles(inSubpaths) {
            const shapes = [];
            for(let i = 0, l = inSubpaths.length; i < l; i++){
                const tmpPath = inSubpaths[i];
                const tmpShape = new $d5b85d29c0b78636$export$6428a7f2611ef1fa();
                tmpShape.curves = tmpPath.curves;
                shapes.push(tmpShape);
            }
            return shapes;
        }
        function isPointInsidePolygon(inPt, inPolygon) {
            const polyLen = inPolygon.length;
            // inPt on polygon contour => immediate success    or
            // toggling of inside/outside at every single! intersection point of an edge
            //  with the horizontal line through inPt, left of inPt
            //  not counting lowerY endpoints of edges and whole edges on that line
            let inside = false;
            for(let p = polyLen - 1, q = 0; q < polyLen; p = q++){
                let edgeLowPt = inPolygon[p];
                let edgeHighPt = inPolygon[q];
                let edgeDx = edgeHighPt.x - edgeLowPt.x;
                let edgeDy = edgeHighPt.y - edgeLowPt.y;
                if (Math.abs(edgeDy) > Number.EPSILON) {
                    // not parallel
                    if (edgeDy < 0) {
                        edgeLowPt = inPolygon[q];
                        edgeDx = -edgeDx;
                        edgeHighPt = inPolygon[p];
                        edgeDy = -edgeDy;
                    }
                    if (inPt.y < edgeLowPt.y || inPt.y > edgeHighPt.y) continue;
                    if (inPt.y === edgeLowPt.y) {
                        if (inPt.x === edgeLowPt.x) return true; // inPt is on contour ?
                    // continue;				// no intersection or edgeLowPt => doesn't count !!!
                    } else {
                        const perpEdge = edgeDy * (inPt.x - edgeLowPt.x) - edgeDx * (inPt.y - edgeLowPt.y);
                        if (perpEdge === 0) return true; // inPt is on contour ?
                        if (perpEdge < 0) continue;
                        inside = !inside; // true intersection left of inPt
                    }
                } else {
                    // parallel or collinear
                    if (inPt.y !== edgeLowPt.y) continue; // parallel
                    // edge lies on the same horizontal line as inPt
                    if (edgeHighPt.x <= inPt.x && inPt.x <= edgeLowPt.x || edgeLowPt.x <= inPt.x && inPt.x <= edgeHighPt.x) return true; // inPt: Point on contour !
                // continue;
                }
            }
            return inside;
        }
        const isClockWise = $d5b85d29c0b78636$export$96bdf6d9c66d7ba8.isClockWise;
        const subPaths = this.subPaths;
        if (subPaths.length === 0) return [];
        let solid, tmpPath, tmpShape;
        const shapes = [];
        if (subPaths.length === 1) {
            tmpPath = subPaths[0];
            tmpShape = new $d5b85d29c0b78636$export$6428a7f2611ef1fa();
            tmpShape.curves = tmpPath.curves;
            shapes.push(tmpShape);
            return shapes;
        }
        let holesFirst = !isClockWise(subPaths[0].getPoints());
        holesFirst = isCCW ? !holesFirst : holesFirst;
        // console.log("Holes first", holesFirst);
        const betterShapeHoles = [];
        const newShapes = [];
        let newShapeHoles = [];
        let mainIdx = 0;
        let tmpPoints;
        newShapes[mainIdx] = undefined;
        newShapeHoles[mainIdx] = [];
        for(let i = 0, l = subPaths.length; i < l; i++){
            tmpPath = subPaths[i];
            tmpPoints = tmpPath.getPoints();
            solid = isClockWise(tmpPoints);
            solid = isCCW ? !solid : solid;
            if (solid) {
                if (!holesFirst && newShapes[mainIdx]) mainIdx++;
                newShapes[mainIdx] = {
                    s: new $d5b85d29c0b78636$export$6428a7f2611ef1fa(),
                    p: tmpPoints
                };
                newShapes[mainIdx].s.curves = tmpPath.curves;
                if (holesFirst) mainIdx++;
                newShapeHoles[mainIdx] = [];
            //console.log('cw', i);
            } else newShapeHoles[mainIdx].push({
                h: tmpPath,
                p: tmpPoints[0]
            });
        }
        // only Holes? -> probably all Shapes with wrong orientation
        if (!newShapes[0]) return toShapesNoHoles(subPaths);
        if (newShapes.length > 1) {
            let ambiguous = false;
            let toChange = 0;
            for(let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++)betterShapeHoles[sIdx] = [];
            for(let sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++){
                const sho = newShapeHoles[sIdx];
                for(let hIdx = 0; hIdx < sho.length; hIdx++){
                    const ho = sho[hIdx];
                    let hole_unassigned = true;
                    for(let s2Idx = 0; s2Idx < newShapes.length; s2Idx++)if (isPointInsidePolygon(ho.p, newShapes[s2Idx].p)) {
                        if (sIdx !== s2Idx) toChange++;
                        if (hole_unassigned) {
                            hole_unassigned = false;
                            betterShapeHoles[s2Idx].push(ho);
                        } else ambiguous = true;
                    }
                    if (hole_unassigned) betterShapeHoles[sIdx].push(ho);
                }
            }
            if (toChange > 0 && ambiguous === false) newShapeHoles = betterShapeHoles;
        }
        let tmpHoles;
        for(let i = 0, il = newShapes.length; i < il; i++){
            tmpShape = newShapes[i].s;
            shapes.push(tmpShape);
            tmpHoles = newShapeHoles[i];
            for(let j = 0, jl = tmpHoles.length; j < jl; j++)tmpShape.holes.push(tmpHoles[j].h);
        }
        //console.log("shape", shapes);
        return shapes;
    }
}
class $d5b85d29c0b78636$export$c7c44baae9d9f25f extends $d5b85d29c0b78636$export$ec8b666c5fe2c75a {
    constructor(object, domElement = null){
        super();
        this.object = object;
        this.domElement = domElement;
        this.enabled = true;
        this.state = -1;
        this.keys = {};
        this.mouseButtons = {
            LEFT: null,
            MIDDLE: null,
            RIGHT: null
        };
        this.touches = {
            ONE: null,
            TWO: null
        };
    }
    connect() {}
    disconnect() {}
    dispose() {}
    update() {}
}
function $d5b85d29c0b78636$var$contain(texture, aspect) {
    const imageAspect = texture.image && texture.image.width ? texture.image.width / texture.image.height : 1;
    if (imageAspect > aspect) {
        texture.repeat.x = 1;
        texture.repeat.y = imageAspect / aspect;
        texture.offset.x = 0;
        texture.offset.y = (1 - texture.repeat.y) / 2;
    } else {
        texture.repeat.x = aspect / imageAspect;
        texture.repeat.y = 1;
        texture.offset.x = (1 - texture.repeat.x) / 2;
        texture.offset.y = 0;
    }
    return texture;
}
function $d5b85d29c0b78636$var$cover(texture, aspect) {
    const imageAspect = texture.image && texture.image.width ? texture.image.width / texture.image.height : 1;
    if (imageAspect > aspect) {
        texture.repeat.x = aspect / imageAspect;
        texture.repeat.y = 1;
        texture.offset.x = (1 - texture.repeat.x) / 2;
        texture.offset.y = 0;
    } else {
        texture.repeat.x = 1;
        texture.repeat.y = imageAspect / aspect;
        texture.offset.x = 0;
        texture.offset.y = (1 - texture.repeat.y) / 2;
    }
    return texture;
}
function $d5b85d29c0b78636$var$fill(texture) {
    texture.repeat.x = 1;
    texture.repeat.y = 1;
    texture.offset.x = 0;
    texture.offset.y = 0;
    return texture;
}
/**
 * Given the width, height, format, and type of a texture. Determines how many
 * bytes must be used to represent the texture.
 *
 * @param {Number} width
 * @param {Number} height
 * @param {Number} format
 * @param {Number} type
 * @return {Number} The number of bytes required to represent the texture.
 */ function $d5b85d29c0b78636$export$cc8c3b705bb8e6e2(width, height, format, type) {
    const typeByteLength = $d5b85d29c0b78636$var$getTextureTypeByteLength(type);
    switch(format){
        // https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glTexImage2D.xhtml
        case $d5b85d29c0b78636$export$988473390501ed4b:
            return width * height;
        case $d5b85d29c0b78636$export$cc09ccbf6d1ed449:
            return width * height;
        case $d5b85d29c0b78636$export$9053a81c4a69c289:
            return width * height * 2;
        case $d5b85d29c0b78636$export$4e041a7967d15c4b:
            return width * height / typeByteLength.components * typeByteLength.byteLength;
        case $d5b85d29c0b78636$export$aa92e870a709d190:
            return width * height / typeByteLength.components * typeByteLength.byteLength;
        case $d5b85d29c0b78636$export$6cdf0b461c7ce8a0:
            return width * height * 2 / typeByteLength.components * typeByteLength.byteLength;
        case $d5b85d29c0b78636$export$1ba1c45f9f77d4d7:
            return width * height * 2 / typeByteLength.components * typeByteLength.byteLength;
        case $d5b85d29c0b78636$export$7c67423a5ee6f5eb:
            return width * height * 3 / typeByteLength.components * typeByteLength.byteLength;
        case $d5b85d29c0b78636$export$3f8bb04b555a363c:
            return width * height * 4 / typeByteLength.components * typeByteLength.byteLength;
        case $d5b85d29c0b78636$export$c200e7d26f592f21:
            return width * height * 4 / typeByteLength.components * typeByteLength.byteLength;
        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_s3tc_srgb/
        case $d5b85d29c0b78636$export$21d1799c6d552fc0:
        case $d5b85d29c0b78636$export$afa304c3e981b668:
            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
        case $d5b85d29c0b78636$export$d2a1a68024a3e56c:
        case $d5b85d29c0b78636$export$9a79c424327dacf9:
            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_pvrtc/
        case $d5b85d29c0b78636$export$d0f0355bb3d948e4:
        case $d5b85d29c0b78636$export$b71692456c47b6c3:
            return Math.max(width, 16) * Math.max(height, 8) / 4;
        case $d5b85d29c0b78636$export$19ada9bbb1af3573:
        case $d5b85d29c0b78636$export$b82296714358084c:
            return Math.max(width, 8) * Math.max(height, 8) / 2;
        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_etc/
        case $d5b85d29c0b78636$export$6ab91af2d757aee7:
        case $d5b85d29c0b78636$export$7800993ef8106a6a:
            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
        case $d5b85d29c0b78636$export$23ed8300a860e7d8:
            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
        // https://registry.khronos.org/webgl/extensions/WEBGL_compressed_texture_astc/
        case $d5b85d29c0b78636$export$dc5570b4a2b92d48:
            return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
        case $d5b85d29c0b78636$export$68880cd325f8b2fb:
            return Math.floor((width + 4) / 5) * Math.floor((height + 3) / 4) * 16;
        case $d5b85d29c0b78636$export$7d2c0be323373d95:
            return Math.floor((width + 4) / 5) * Math.floor((height + 4) / 5) * 16;
        case $d5b85d29c0b78636$export$22b52da301fc3a3e:
            return Math.floor((width + 5) / 6) * Math.floor((height + 4) / 5) * 16;
        case $d5b85d29c0b78636$export$c009e2cb4a66485e:
            return Math.floor((width + 5) / 6) * Math.floor((height + 5) / 6) * 16;
        case $d5b85d29c0b78636$export$118fff5afa255b63:
            return Math.floor((width + 7) / 8) * Math.floor((height + 4) / 5) * 16;
        case $d5b85d29c0b78636$export$120713c829ae0667:
            return Math.floor((width + 7) / 8) * Math.floor((height + 5) / 6) * 16;
        case $d5b85d29c0b78636$export$c79eeabbf53313e9:
            return Math.floor((width + 7) / 8) * Math.floor((height + 7) / 8) * 16;
        case $d5b85d29c0b78636$export$443cf6567cdd6424:
            return Math.floor((width + 9) / 10) * Math.floor((height + 4) / 5) * 16;
        case $d5b85d29c0b78636$export$6573984fc9840780:
            return Math.floor((width + 9) / 10) * Math.floor((height + 5) / 6) * 16;
        case $d5b85d29c0b78636$export$e7aee563f30091de:
            return Math.floor((width + 9) / 10) * Math.floor((height + 7) / 8) * 16;
        case $d5b85d29c0b78636$export$2eb8634622ddeab7:
            return Math.floor((width + 9) / 10) * Math.floor((height + 9) / 10) * 16;
        case $d5b85d29c0b78636$export$202b1ce7b5d25742:
            return Math.floor((width + 11) / 12) * Math.floor((height + 9) / 10) * 16;
        case $d5b85d29c0b78636$export$18ab77abd087e467:
            return Math.floor((width + 11) / 12) * Math.floor((height + 11) / 12) * 16;
        // https://registry.khronos.org/webgl/extensions/EXT_texture_compression_bptc/
        case $d5b85d29c0b78636$export$ce40b115e188bc81:
        case $d5b85d29c0b78636$export$d279c5c4bac5121e:
        case $d5b85d29c0b78636$export$cde52d17225fdbd3:
            return Math.ceil(width / 4) * Math.ceil(height / 4) * 16;
        // https://registry.khronos.org/webgl/extensions/EXT_texture_compression_rgtc/
        case $d5b85d29c0b78636$export$b1688df4c4c21670:
        case $d5b85d29c0b78636$export$fc15e5d8261eed58:
            return Math.ceil(width / 4) * Math.ceil(height / 4) * 8;
        case $d5b85d29c0b78636$export$d220f6ade8463a0f:
        case $d5b85d29c0b78636$export$768646d09dc1b6ef:
            return Math.ceil(width / 4) * Math.ceil(height / 4) * 16;
    }
    throw new Error(`Unable to determine texture byte length for ${format} format.`);
}
function $d5b85d29c0b78636$var$getTextureTypeByteLength(type) {
    switch(type){
        case $d5b85d29c0b78636$export$2e8ce08d3f6f5e10:
        case $d5b85d29c0b78636$export$545fce0311a9796a:
            return {
                byteLength: 1,
                components: 1
            };
        case $d5b85d29c0b78636$export$c63dc51868b06a9d:
        case $d5b85d29c0b78636$export$88572337f312435f:
        case $d5b85d29c0b78636$export$2697304443f382bc:
            return {
                byteLength: 2,
                components: 1
            };
        case $d5b85d29c0b78636$export$b3969b01faf587f2:
        case $d5b85d29c0b78636$export$18886f8ae33e90de:
            return {
                byteLength: 2,
                components: 4
            };
        case $d5b85d29c0b78636$export$c3c7fc4518ebba96:
        case $d5b85d29c0b78636$export$5c612977753abe2:
        case $d5b85d29c0b78636$export$f6d331659b644596:
            return {
                byteLength: 4,
                components: 1
            };
        case $d5b85d29c0b78636$export$5a4c329b7e2092d3:
            return {
                byteLength: 4,
                components: 3
            };
    }
    throw new Error(`Unknown texture type ${type}.`);
}
const $d5b85d29c0b78636$export$ec276d39f33d4b7 = {
    contain: $d5b85d29c0b78636$var$contain,
    cover: $d5b85d29c0b78636$var$cover,
    fill: $d5b85d29c0b78636$var$fill,
    getByteLength: $d5b85d29c0b78636$export$cc8c3b705bb8e6e2
};
if (typeof __THREE_DEVTOOLS__ !== 'undefined') __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent('register', {
    detail: {
        revision: $d5b85d29c0b78636$export$3545e07a80636437
    }
}));
if (typeof window !== 'undefined') {
    if (window.__THREE__) console.warn('WARNING: Multiple instances of Three.js being imported.');
    else window.__THREE__ = $d5b85d29c0b78636$export$3545e07a80636437;
}


function $3dd44ec8564e7230$var$WebGLAnimation() {
    let context = null;
    let isAnimating = false;
    let animationLoop = null;
    let requestId = null;
    function onAnimationFrame(time, frame) {
        animationLoop(time, frame);
        requestId = context.requestAnimationFrame(onAnimationFrame);
    }
    return {
        start: function() {
            if (isAnimating === true) return;
            if (animationLoop === null) return;
            requestId = context.requestAnimationFrame(onAnimationFrame);
            isAnimating = true;
        },
        stop: function() {
            context.cancelAnimationFrame(requestId);
            isAnimating = false;
        },
        setAnimationLoop: function(callback) {
            animationLoop = callback;
        },
        setContext: function(value) {
            context = value;
        }
    };
}
function $3dd44ec8564e7230$var$WebGLAttributes(gl) {
    const buffers = new WeakMap();
    function createBuffer(attribute, bufferType) {
        const array = attribute.array;
        const usage = attribute.usage;
        const size = array.byteLength;
        const buffer = gl.createBuffer();
        gl.bindBuffer(bufferType, buffer);
        gl.bufferData(bufferType, array, usage);
        attribute.onUploadCallback();
        let type;
        if (array instanceof Float32Array) type = gl.FLOAT;
        else if (array instanceof Uint16Array) {
            if (attribute.isFloat16BufferAttribute) type = gl.HALF_FLOAT;
            else type = gl.UNSIGNED_SHORT;
        } else if (array instanceof Int16Array) type = gl.SHORT;
        else if (array instanceof Uint32Array) type = gl.UNSIGNED_INT;
        else if (array instanceof Int32Array) type = gl.INT;
        else if (array instanceof Int8Array) type = gl.BYTE;
        else if (array instanceof Uint8Array) type = gl.UNSIGNED_BYTE;
        else if (array instanceof Uint8ClampedArray) type = gl.UNSIGNED_BYTE;
        else throw new Error('THREE.WebGLAttributes: Unsupported buffer data format: ' + array);
        return {
            buffer: buffer,
            type: type,
            bytesPerElement: array.BYTES_PER_ELEMENT,
            version: attribute.version,
            size: size
        };
    }
    function updateBuffer(buffer, attribute, bufferType) {
        const array = attribute.array;
        const updateRanges = attribute.updateRanges;
        gl.bindBuffer(bufferType, buffer);
        if (updateRanges.length === 0) // Not using update ranges
        gl.bufferSubData(bufferType, 0, array);
        else {
            // Before applying update ranges, we merge any adjacent / overlapping
            // ranges to reduce load on `gl.bufferSubData`. Empirically, this has led
            // to performance improvements for applications which make heavy use of
            // update ranges. Likely due to GPU command overhead.
            //
            // Note that to reduce garbage collection between frames, we merge the
            // update ranges in-place. This is safe because this method will clear the
            // update ranges once updated.
            updateRanges.sort((a, b)=>a.start - b.start);
            // To merge the update ranges in-place, we work from left to right in the
            // existing updateRanges array, merging ranges. This may result in a final
            // array which is smaller than the original. This index tracks the last
            // index representing a merged range, any data after this index can be
            // trimmed once the merge algorithm is completed.
            let mergeIndex = 0;
            for(let i = 1; i < updateRanges.length; i++){
                const previousRange = updateRanges[mergeIndex];
                const range = updateRanges[i];
                // We add one here to merge adjacent ranges. This is safe because ranges
                // operate over positive integers.
                if (range.start <= previousRange.start + previousRange.count + 1) previousRange.count = Math.max(previousRange.count, range.start + range.count - previousRange.start);
                else {
                    ++mergeIndex;
                    updateRanges[mergeIndex] = range;
                }
            }
            // Trim the array to only contain the merged ranges.
            updateRanges.length = mergeIndex + 1;
            for(let i = 0, l = updateRanges.length; i < l; i++){
                const range = updateRanges[i];
                gl.bufferSubData(bufferType, range.start * array.BYTES_PER_ELEMENT, array, range.start, range.count);
            }
            attribute.clearUpdateRanges();
        }
        attribute.onUploadCallback();
    }
    //
    function get(attribute) {
        if (attribute.isInterleavedBufferAttribute) attribute = attribute.data;
        return buffers.get(attribute);
    }
    function remove(attribute) {
        if (attribute.isInterleavedBufferAttribute) attribute = attribute.data;
        const data = buffers.get(attribute);
        if (data) {
            gl.deleteBuffer(data.buffer);
            buffers.delete(attribute);
        }
    }
    function update(attribute, bufferType) {
        if (attribute.isInterleavedBufferAttribute) attribute = attribute.data;
        if (attribute.isGLBufferAttribute) {
            const cached = buffers.get(attribute);
            if (!cached || cached.version < attribute.version) buffers.set(attribute, {
                buffer: attribute.buffer,
                type: attribute.type,
                bytesPerElement: attribute.elementSize,
                version: attribute.version
            });
            return;
        }
        const data = buffers.get(attribute);
        if (data === undefined) buffers.set(attribute, createBuffer(attribute, bufferType));
        else if (data.version < attribute.version) {
            if (data.size !== attribute.array.byteLength) throw new Error('THREE.WebGLAttributes: The size of the buffer attribute\'s array buffer does not match the original size. Resizing buffer attributes is not supported.');
            updateBuffer(data.buffer, attribute, bufferType);
            data.version = attribute.version;
        }
    }
    return {
        get: get,
        remove: remove,
        update: update
    };
}
var $3dd44ec8564e7230$var$alphahash_fragment = "#ifdef USE_ALPHAHASH\n\tif ( diffuseColor.a < getAlphaHashThreshold( vPosition ) ) discard;\n#endif";
var $3dd44ec8564e7230$var$alphahash_pars_fragment = "#ifdef USE_ALPHAHASH\n\tconst float ALPHA_HASH_SCALE = 0.05;\n\tfloat hash2D( vec2 value ) {\n\t\treturn fract( 1.0e4 * sin( 17.0 * value.x + 0.1 * value.y ) * ( 0.1 + abs( sin( 13.0 * value.y + value.x ) ) ) );\n\t}\n\tfloat hash3D( vec3 value ) {\n\t\treturn hash2D( vec2( hash2D( value.xy ), value.z ) );\n\t}\n\tfloat getAlphaHashThreshold( vec3 position ) {\n\t\tfloat maxDeriv = max(\n\t\t\tlength( dFdx( position.xyz ) ),\n\t\t\tlength( dFdy( position.xyz ) )\n\t\t);\n\t\tfloat pixScale = 1.0 / ( ALPHA_HASH_SCALE * maxDeriv );\n\t\tvec2 pixScales = vec2(\n\t\t\texp2( floor( log2( pixScale ) ) ),\n\t\t\texp2( ceil( log2( pixScale ) ) )\n\t\t);\n\t\tvec2 alpha = vec2(\n\t\t\thash3D( floor( pixScales.x * position.xyz ) ),\n\t\t\thash3D( floor( pixScales.y * position.xyz ) )\n\t\t);\n\t\tfloat lerpFactor = fract( log2( pixScale ) );\n\t\tfloat x = ( 1.0 - lerpFactor ) * alpha.x + lerpFactor * alpha.y;\n\t\tfloat a = min( lerpFactor, 1.0 - lerpFactor );\n\t\tvec3 cases = vec3(\n\t\t\tx * x / ( 2.0 * a * ( 1.0 - a ) ),\n\t\t\t( x - 0.5 * a ) / ( 1.0 - a ),\n\t\t\t1.0 - ( ( 1.0 - x ) * ( 1.0 - x ) / ( 2.0 * a * ( 1.0 - a ) ) )\n\t\t);\n\t\tfloat threshold = ( x < ( 1.0 - a ) )\n\t\t\t? ( ( x < a ) ? cases.x : cases.y )\n\t\t\t: cases.z;\n\t\treturn clamp( threshold , 1.0e-6, 1.0 );\n\t}\n#endif";
var $3dd44ec8564e7230$var$alphamap_fragment = "#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vAlphaMapUv ).g;\n#endif";
var $3dd44ec8564e7230$var$alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";
var $3dd44ec8564e7230$var$alphatest_fragment = "#ifdef USE_ALPHATEST\n\t#ifdef ALPHA_TO_COVERAGE\n\tdiffuseColor.a = smoothstep( alphaTest, alphaTest + fwidth( diffuseColor.a ), diffuseColor.a );\n\tif ( diffuseColor.a == 0.0 ) discard;\n\t#else\n\tif ( diffuseColor.a < alphaTest ) discard;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$alphatest_pars_fragment = "#ifdef USE_ALPHATEST\n\tuniform float alphaTest;\n#endif";
var $3dd44ec8564e7230$var$aomap_fragment = "#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vAoMapUv ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_CLEARCOAT ) \n\t\tclearcoatSpecularIndirect *= ambientOcclusion;\n\t#endif\n\t#if defined( USE_SHEEN ) \n\t\tsheenSpecularIndirect *= ambientOcclusion;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometryNormal, geometryViewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.roughness );\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$aomap_pars_fragment = "#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif";
var $3dd44ec8564e7230$var$batching_pars_vertex = "#ifdef USE_BATCHING\n\t#if ! defined( GL_ANGLE_multi_draw )\n\t#define gl_DrawID _gl_DrawID\n\tuniform int _gl_DrawID;\n\t#endif\n\tuniform highp sampler2D batchingTexture;\n\tuniform highp usampler2D batchingIdTexture;\n\tmat4 getBatchingMatrix( const in float i ) {\n\t\tint size = textureSize( batchingTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( batchingTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( batchingTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( batchingTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( batchingTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n\tfloat getIndirectIndex( const in int i ) {\n\t\tint size = textureSize( batchingIdTexture, 0 ).x;\n\t\tint x = i % size;\n\t\tint y = i / size;\n\t\treturn float( texelFetch( batchingIdTexture, ivec2( x, y ), 0 ).r );\n\t}\n#endif\n#ifdef USE_BATCHING_COLOR\n\tuniform sampler2D batchingColorTexture;\n\tvec3 getBatchingColor( const in float i ) {\n\t\tint size = textureSize( batchingColorTexture, 0 ).x;\n\t\tint j = int( i );\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\treturn texelFetch( batchingColorTexture, ivec2( x, y ), 0 ).rgb;\n\t}\n#endif";
var $3dd44ec8564e7230$var$batching_vertex = "#ifdef USE_BATCHING\n\tmat4 batchingMatrix = getBatchingMatrix( getIndirectIndex( gl_DrawID ) );\n#endif";
var $3dd44ec8564e7230$var$begin_vertex = "vec3 transformed = vec3( position );\n#ifdef USE_ALPHAHASH\n\tvPosition = vec3( position );\n#endif";
var $3dd44ec8564e7230$var$beginnormal_vertex = "vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif";
var $3dd44ec8564e7230$var$bsdfs = "float G_BlinnPhong_Implicit( ) {\n\treturn 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_BlinnPhong( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, 1.0, dotVH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n} // validated";
var $3dd44ec8564e7230$var$iridescence_fragment = "#ifdef USE_IRIDESCENCE\n\tconst mat3 XYZ_TO_REC709 = mat3(\n\t\t 3.2404542, -0.9692660,  0.0556434,\n\t\t-1.5371385,  1.8760108, -0.2040259,\n\t\t-0.4985314,  0.0415560,  1.0572252\n\t);\n\tvec3 Fresnel0ToIor( vec3 fresnel0 ) {\n\t\tvec3 sqrtF0 = sqrt( fresnel0 );\n\t\treturn ( vec3( 1.0 ) + sqrtF0 ) / ( vec3( 1.0 ) - sqrtF0 );\n\t}\n\tvec3 IorToFresnel0( vec3 transmittedIor, float incidentIor ) {\n\t\treturn pow2( ( transmittedIor - vec3( incidentIor ) ) / ( transmittedIor + vec3( incidentIor ) ) );\n\t}\n\tfloat IorToFresnel0( float transmittedIor, float incidentIor ) {\n\t\treturn pow2( ( transmittedIor - incidentIor ) / ( transmittedIor + incidentIor ));\n\t}\n\tvec3 evalSensitivity( float OPD, vec3 shift ) {\n\t\tfloat phase = 2.0 * PI * OPD * 1.0e-9;\n\t\tvec3 val = vec3( 5.4856e-13, 4.4201e-13, 5.2481e-13 );\n\t\tvec3 pos = vec3( 1.6810e+06, 1.7953e+06, 2.2084e+06 );\n\t\tvec3 var = vec3( 4.3278e+09, 9.3046e+09, 6.6121e+09 );\n\t\tvec3 xyz = val * sqrt( 2.0 * PI * var ) * cos( pos * phase + shift ) * exp( - pow2( phase ) * var );\n\t\txyz.x += 9.7470e-14 * sqrt( 2.0 * PI * 4.5282e+09 ) * cos( 2.2399e+06 * phase + shift[ 0 ] ) * exp( - 4.5282e+09 * pow2( phase ) );\n\t\txyz /= 1.0685e-7;\n\t\tvec3 rgb = XYZ_TO_REC709 * xyz;\n\t\treturn rgb;\n\t}\n\tvec3 evalIridescence( float outsideIOR, float eta2, float cosTheta1, float thinFilmThickness, vec3 baseF0 ) {\n\t\tvec3 I;\n\t\tfloat iridescenceIOR = mix( outsideIOR, eta2, smoothstep( 0.0, 0.03, thinFilmThickness ) );\n\t\tfloat sinTheta2Sq = pow2( outsideIOR / iridescenceIOR ) * ( 1.0 - pow2( cosTheta1 ) );\n\t\tfloat cosTheta2Sq = 1.0 - sinTheta2Sq;\n\t\tif ( cosTheta2Sq < 0.0 ) {\n\t\t\treturn vec3( 1.0 );\n\t\t}\n\t\tfloat cosTheta2 = sqrt( cosTheta2Sq );\n\t\tfloat R0 = IorToFresnel0( iridescenceIOR, outsideIOR );\n\t\tfloat R12 = F_Schlick( R0, 1.0, cosTheta1 );\n\t\tfloat T121 = 1.0 - R12;\n\t\tfloat phi12 = 0.0;\n\t\tif ( iridescenceIOR < outsideIOR ) phi12 = PI;\n\t\tfloat phi21 = PI - phi12;\n\t\tvec3 baseIOR = Fresnel0ToIor( clamp( baseF0, 0.0, 0.9999 ) );\t\tvec3 R1 = IorToFresnel0( baseIOR, iridescenceIOR );\n\t\tvec3 R23 = F_Schlick( R1, 1.0, cosTheta2 );\n\t\tvec3 phi23 = vec3( 0.0 );\n\t\tif ( baseIOR[ 0 ] < iridescenceIOR ) phi23[ 0 ] = PI;\n\t\tif ( baseIOR[ 1 ] < iridescenceIOR ) phi23[ 1 ] = PI;\n\t\tif ( baseIOR[ 2 ] < iridescenceIOR ) phi23[ 2 ] = PI;\n\t\tfloat OPD = 2.0 * iridescenceIOR * thinFilmThickness * cosTheta2;\n\t\tvec3 phi = vec3( phi21 ) + phi23;\n\t\tvec3 R123 = clamp( R12 * R23, 1e-5, 0.9999 );\n\t\tvec3 r123 = sqrt( R123 );\n\t\tvec3 Rs = pow2( T121 ) * R23 / ( vec3( 1.0 ) - R123 );\n\t\tvec3 C0 = R12 + Rs;\n\t\tI = C0;\n\t\tvec3 Cm = Rs - T121;\n\t\tfor ( int m = 1; m <= 2; ++ m ) {\n\t\t\tCm *= r123;\n\t\t\tvec3 Sm = 2.0 * evalSensitivity( float( m ) * OPD, float( m ) * phi );\n\t\t\tI += Cm * Sm;\n\t\t}\n\t\treturn max( I, vec3( 0.0 ) );\n\t}\n#endif";
var $3dd44ec8564e7230$var$bumpmap_pars_fragment = "#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vBumpMapUv );\n\t\tvec2 dSTdy = dFdy( vBumpMapUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vBumpMapUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vBumpMapUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy, float faceDirection ) {\n\t\tvec3 vSigmaX = normalize( dFdx( surf_pos.xyz ) );\n\t\tvec3 vSigmaY = normalize( dFdy( surf_pos.xyz ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 ) * faceDirection;\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif";
var $3dd44ec8564e7230$var$clipping_planes_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#ifdef ALPHA_TO_COVERAGE\n\t\tfloat distanceToPlane, distanceGradient;\n\t\tfloat clipOpacity = 1.0;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n\t\t\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\n\t\t\tclipOpacity *= smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n\t\t\tif ( clipOpacity == 0.0 ) discard;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\t\tfloat unionClipOpacity = 1.0;\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\t\tplane = clippingPlanes[ i ];\n\t\t\t\tdistanceToPlane = - dot( vClipPosition, plane.xyz ) + plane.w;\n\t\t\t\tdistanceGradient = fwidth( distanceToPlane ) / 2.0;\n\t\t\t\tunionClipOpacity *= 1.0 - smoothstep( - distanceGradient, distanceGradient, distanceToPlane );\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\t\t\tclipOpacity *= 1.0 - unionClipOpacity;\n\t\t#endif\n\t\tdiffuseColor.a *= clipOpacity;\n\t\tif ( diffuseColor.a == 0.0 ) discard;\n\t#else\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\t\tbool clipped = true;\n\t\t\t#pragma unroll_loop_start\n\t\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\t\tplane = clippingPlanes[ i ];\n\t\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t\t}\n\t\t\t#pragma unroll_loop_end\n\t\t\tif ( clipped ) discard;\n\t\t#endif\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$clipping_planes_pars_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif";
var $3dd44ec8564e7230$var$clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif";
var $3dd44ec8564e7230$var$clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif";
var $3dd44ec8564e7230$var$color_fragment = "#if defined( USE_COLOR_ALPHA )\n\tdiffuseColor *= vColor;\n#elif defined( USE_COLOR )\n\tdiffuseColor.rgb *= vColor;\n#endif";
var $3dd44ec8564e7230$var$color_pars_fragment = "#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR )\n\tvarying vec3 vColor;\n#endif";
var $3dd44ec8564e7230$var$color_pars_vertex = "#if defined( USE_COLOR_ALPHA )\n\tvarying vec4 vColor;\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )\n\tvarying vec3 vColor;\n#endif";
var $3dd44ec8564e7230$var$color_vertex = "#if defined( USE_COLOR_ALPHA )\n\tvColor = vec4( 1.0 );\n#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor *= color;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif\n#ifdef USE_BATCHING_COLOR\n\tvec3 batchingColor = getBatchingColor( getIndirectIndex( gl_DrawID ) );\n\tvColor.xyz *= batchingColor.xyz;\n#endif";
var $3dd44ec8564e7230$var$common = "#define PI 3.141592653589793\n#define PI2 6.283185307179586\n#define PI_HALF 1.5707963267948966\n#define RECIPROCAL_PI 0.3183098861837907\n#define RECIPROCAL_PI2 0.15915494309189535\n#define EPSILON 1e-6\n#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\n#define whiteComplement( a ) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nvec3 pow2( const in vec3 x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat max3( const in vec3 v ) { return max( max( v.x, v.y ), v.z ); }\nfloat average( const in vec3 v ) { return dot( v, vec3( 0.3333333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract( sin( sn ) * c );\n}\n#ifdef HIGH_PRECISION\n\tfloat precisionSafeLength( vec3 v ) { return length( v ); }\n#else\n\tfloat precisionSafeLength( vec3 v ) {\n\t\tfloat maxComponent = max3( abs( v ) );\n\t\treturn length( v / maxComponent ) * maxComponent;\n\t}\n#endif\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\n#ifdef USE_ALPHAHASH\n\tvarying vec3 vPosition;\n#endif\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nmat3 transposeMat3( const in mat3 m ) {\n\tmat3 tmp;\n\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\n\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\n\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\n\treturn tmp;\n}\nbool isPerspectiveMatrix( mat4 m ) {\n\treturn m[ 2 ][ 3 ] == - 1.0;\n}\nvec2 equirectUv( in vec3 dir ) {\n\tfloat u = atan( dir.z, dir.x ) * RECIPROCAL_PI2 + 0.5;\n\tfloat v = asin( clamp( dir.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\n\treturn vec2( u, v );\n}\nvec3 BRDF_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n}\nfloat F_Schlick( const in float f0, const in float f90, const in float dotVH ) {\n\tfloat fresnel = exp2( ( - 5.55473 * dotVH - 6.98316 ) * dotVH );\n\treturn f0 * ( 1.0 - fresnel ) + ( f90 * fresnel );\n} // validated";
var $3dd44ec8564e7230$var$cube_uv_reflection_fragment = "#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_minTileSize 16.0\n\tfloat getFace( vec3 direction ) {\n\t\tvec3 absDirection = abs( direction );\n\t\tfloat face = - 1.0;\n\t\tif ( absDirection.x > absDirection.z ) {\n\t\t\tif ( absDirection.x > absDirection.y )\n\t\t\t\tface = direction.x > 0.0 ? 0.0 : 3.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t} else {\n\t\t\tif ( absDirection.z > absDirection.y )\n\t\t\t\tface = direction.z > 0.0 ? 2.0 : 5.0;\n\t\t\telse\n\t\t\t\tface = direction.y > 0.0 ? 1.0 : 4.0;\n\t\t}\n\t\treturn face;\n\t}\n\tvec2 getUV( vec3 direction, float face ) {\n\t\tvec2 uv;\n\t\tif ( face == 0.0 ) {\n\t\t\tuv = vec2( direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 1.0 ) {\n\t\t\tuv = vec2( - direction.x, - direction.z ) / abs( direction.y );\n\t\t} else if ( face == 2.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.y ) / abs( direction.z );\n\t\t} else if ( face == 3.0 ) {\n\t\t\tuv = vec2( - direction.z, direction.y ) / abs( direction.x );\n\t\t} else if ( face == 4.0 ) {\n\t\t\tuv = vec2( - direction.x, direction.z ) / abs( direction.y );\n\t\t} else {\n\t\t\tuv = vec2( direction.x, direction.y ) / abs( direction.z );\n\t\t}\n\t\treturn 0.5 * ( uv + 1.0 );\n\t}\n\tvec3 bilinearCubeUV( sampler2D envMap, vec3 direction, float mipInt ) {\n\t\tfloat face = getFace( direction );\n\t\tfloat filterInt = max( cubeUV_minMipLevel - mipInt, 0.0 );\n\t\tmipInt = max( mipInt, cubeUV_minMipLevel );\n\t\tfloat faceSize = exp2( mipInt );\n\t\thighp vec2 uv = getUV( direction, face ) * ( faceSize - 2.0 ) + 1.0;\n\t\tif ( face > 2.0 ) {\n\t\t\tuv.y += faceSize;\n\t\t\tface -= 3.0;\n\t\t}\n\t\tuv.x += face * faceSize;\n\t\tuv.x += filterInt * 3.0 * cubeUV_minTileSize;\n\t\tuv.y += 4.0 * ( exp2( CUBEUV_MAX_MIP ) - faceSize );\n\t\tuv.x *= CUBEUV_TEXEL_WIDTH;\n\t\tuv.y *= CUBEUV_TEXEL_HEIGHT;\n\t\t#ifdef texture2DGradEXT\n\t\t\treturn texture2DGradEXT( envMap, uv, vec2( 0.0 ), vec2( 0.0 ) ).rgb;\n\t\t#else\n\t\t\treturn texture2D( envMap, uv ).rgb;\n\t\t#endif\n\t}\n\t#define cubeUV_r0 1.0\n\t#define cubeUV_m0 - 2.0\n\t#define cubeUV_r1 0.8\n\t#define cubeUV_m1 - 1.0\n\t#define cubeUV_r4 0.4\n\t#define cubeUV_m4 2.0\n\t#define cubeUV_r5 0.305\n\t#define cubeUV_m5 3.0\n\t#define cubeUV_r6 0.21\n\t#define cubeUV_m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= cubeUV_r1 ) {\n\t\t\tmip = ( cubeUV_r0 - roughness ) * ( cubeUV_m1 - cubeUV_m0 ) / ( cubeUV_r0 - cubeUV_r1 ) + cubeUV_m0;\n\t\t} else if ( roughness >= cubeUV_r4 ) {\n\t\t\tmip = ( cubeUV_r1 - roughness ) * ( cubeUV_m4 - cubeUV_m1 ) / ( cubeUV_r1 - cubeUV_r4 ) + cubeUV_m1;\n\t\t} else if ( roughness >= cubeUV_r5 ) {\n\t\t\tmip = ( cubeUV_r4 - roughness ) * ( cubeUV_m5 - cubeUV_m4 ) / ( cubeUV_r4 - cubeUV_r5 ) + cubeUV_m4;\n\t\t} else if ( roughness >= cubeUV_r6 ) {\n\t\t\tmip = ( cubeUV_r5 - roughness ) * ( cubeUV_m6 - cubeUV_m5 ) / ( cubeUV_r5 - cubeUV_r6 ) + cubeUV_m5;\n\t\t} else {\n\t\t\tmip = - 2.0 * log2( 1.16 * roughness );\t\t}\n\t\treturn mip;\n\t}\n\tvec4 textureCubeUV( sampler2D envMap, vec3 sampleDir, float roughness ) {\n\t\tfloat mip = clamp( roughnessToMip( roughness ), cubeUV_m0, CUBEUV_MAX_MIP );\n\t\tfloat mipF = fract( mip );\n\t\tfloat mipInt = floor( mip );\n\t\tvec3 color0 = bilinearCubeUV( envMap, sampleDir, mipInt );\n\t\tif ( mipF == 0.0 ) {\n\t\t\treturn vec4( color0, 1.0 );\n\t\t} else {\n\t\t\tvec3 color1 = bilinearCubeUV( envMap, sampleDir, mipInt + 1.0 );\n\t\t\treturn vec4( mix( color0, color1, mipF ), 1.0 );\n\t\t}\n\t}\n#endif";
var $3dd44ec8564e7230$var$defaultnormal_vertex = "vec3 transformedNormal = objectNormal;\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = objectTangent;\n#endif\n#ifdef USE_BATCHING\n\tmat3 bm = mat3( batchingMatrix );\n\ttransformedNormal /= vec3( dot( bm[ 0 ], bm[ 0 ] ), dot( bm[ 1 ], bm[ 1 ] ), dot( bm[ 2 ], bm[ 2 ] ) );\n\ttransformedNormal = bm * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = bm * transformedTangent;\n\t#endif\n#endif\n#ifdef USE_INSTANCING\n\tmat3 im = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( im[ 0 ], im[ 0 ] ), dot( im[ 1 ], im[ 1 ] ), dot( im[ 2 ], im[ 2 ] ) );\n\ttransformedNormal = im * transformedNormal;\n\t#ifdef USE_TANGENT\n\t\ttransformedTangent = im * transformedTangent;\n\t#endif\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\ttransformedTangent = ( modelViewMatrix * vec4( transformedTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif";
var $3dd44ec8564e7230$var$displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vDisplacementMapUv ).x * displacementScale + displacementBias );\n#endif";
var $3dd44ec8564e7230$var$emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vEmissiveMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE_EMISSIVE\n\t\temissiveColor = sRGBTransferEOTF( emissiveColor );\n\t#endif\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif";
var $3dd44ec8564e7230$var$emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif";
var $3dd44ec8564e7230$var$colorspace_fragment = "gl_FragColor = linearToOutputTexel( gl_FragColor );";
var $3dd44ec8564e7230$var$colorspace_pars_fragment = "vec4 LinearTransferOETF( in vec4 value ) {\n\treturn value;\n}\nvec4 sRGBTransferEOTF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.a );\n}\nvec4 sRGBTransferOETF( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.a );\n}";
var $3dd44ec8564e7230$var$envmap_fragment = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvec3 cameraToFrag;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToFrag = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToFrag = normalize( vWorldPosition - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToFrag, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToFrag, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, envMapRotation * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$envmap_common_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform mat3 envMapRotation;\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\t\n#endif";
var $3dd44ec8564e7230$var$envmap_pars_fragment = "#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\tvarying vec3 vWorldPosition;\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$envmap_pars_vertex = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( LAMBERT )\n\t\t#define ENV_WORLDPOS\n\t#endif\n\t#ifdef ENV_WORLDPOS\n\t\t\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$envmap_vertex = "#ifdef USE_ENVMAP\n\t#ifdef ENV_WORLDPOS\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex;\n\t\tif ( isOrthographic ) {\n\t\t\tcameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );\n\t\t} else {\n\t\t\tcameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\t}\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$fog_vertex = "#ifdef USE_FOG\n\tvFogDepth = - mvPosition.z;\n#endif";
var $3dd44ec8564e7230$var$fog_pars_vertex = "#ifdef USE_FOG\n\tvarying float vFogDepth;\n#endif";
var $3dd44ec8564e7230$var$fog_fragment = "#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * vFogDepth * vFogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, vFogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif";
var $3dd44ec8564e7230$var$fog_pars_fragment = "#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float vFogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$gradientmap_pars_fragment = "#ifdef USE_GRADIENTMAP\n\tuniform sampler2D gradientMap;\n#endif\nvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\tfloat dotNL = dot( normal, lightDirection );\n\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t#ifdef USE_GRADIENTMAP\n\t\treturn vec3( texture2D( gradientMap, coord ).r );\n\t#else\n\t\tvec2 fw = fwidth( coord ) * 0.5;\n\t\treturn mix( vec3( 0.7 ), vec3( 1.0 ), smoothstep( 0.7 - fw.x, 0.7 + fw.x, coord.x ) );\n\t#endif\n}";
var $3dd44ec8564e7230$var$lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif";
var $3dd44ec8564e7230$var$lights_lambert_fragment = "LambertMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularStrength = specularStrength;";
var $3dd44ec8564e7230$var$lights_lambert_pars_fragment = "varying vec3 vViewPosition;\nstruct LambertMaterial {\n\tvec3 diffuseColor;\n\tfloat specularStrength;\n};\nvoid RE_Direct_Lambert( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Lambert( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in LambertMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Lambert\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Lambert";
var $3dd44ec8564e7230$var$lights_pars_begin = "uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\n#if defined( USE_LIGHT_PROBES )\n\tuniform vec3 lightProbe[ 9 ];\n#endif\nvec3 shGetIrradianceAt( in vec3 normal, in vec3 shCoefficients[ 9 ] ) {\n\tfloat x = normal.x, y = normal.y, z = normal.z;\n\tvec3 result = shCoefficients[ 0 ] * 0.886227;\n\tresult += shCoefficients[ 1 ] * 2.0 * 0.511664 * y;\n\tresult += shCoefficients[ 2 ] * 2.0 * 0.511664 * z;\n\tresult += shCoefficients[ 3 ] * 2.0 * 0.511664 * x;\n\tresult += shCoefficients[ 4 ] * 2.0 * 0.429043 * x * y;\n\tresult += shCoefficients[ 5 ] * 2.0 * 0.429043 * y * z;\n\tresult += shCoefficients[ 6 ] * ( 0.743125 * z * z - 0.247708 );\n\tresult += shCoefficients[ 7 ] * 2.0 * 0.429043 * x * z;\n\tresult += shCoefficients[ 8 ] * 0.429043 * ( x * x - y * y );\n\treturn result;\n}\nvec3 getLightProbeIrradiance( const in vec3 lightProbe[ 9 ], const in vec3 normal ) {\n\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\treturn irradiance;\n}\nfloat getDistanceAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\tif ( cutoffDistance > 0.0 ) {\n\t\tdistanceFalloff *= pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t}\n\treturn distanceFalloff;\n}\nfloat getSpotAttenuation( const in float coneCosine, const in float penumbraCosine, const in float angleCosine ) {\n\treturn smoothstep( coneCosine, penumbraCosine, angleCosine );\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalLightInfo( const in DirectionalLight directionalLight, out IncidentLight light ) {\n\t\tlight.color = directionalLight.color;\n\t\tlight.direction = directionalLight.direction;\n\t\tlight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointLightInfo( const in PointLight pointLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = pointLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tlight.color = pointLight.color;\n\t\tlight.color *= getDistanceAttenuation( lightDistance, pointLight.distance, pointLight.decay );\n\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotLightInfo( const in SpotLight spotLight, const in vec3 geometryPosition, out IncidentLight light ) {\n\t\tvec3 lVector = spotLight.position - geometryPosition;\n\t\tlight.direction = normalize( lVector );\n\t\tfloat angleCos = dot( light.direction, spotLight.direction );\n\t\tfloat spotAttenuation = getSpotAttenuation( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\tif ( spotAttenuation > 0.0 ) {\n\t\t\tfloat lightDistance = length( lVector );\n\t\t\tlight.color = spotLight.color * spotAttenuation;\n\t\t\tlight.color *= getDistanceAttenuation( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tlight.visible = ( light.color != vec3( 0.0 ) );\n\t\t} else {\n\t\t\tlight.color = vec3( 0.0 );\n\t\t\tlight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltc_1;\tuniform sampler2D ltc_2;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in vec3 normal ) {\n\t\tfloat dotNL = dot( normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\treturn irradiance;\n\t}\n#endif";
var $3dd44ec8564e7230$var$envmap_physical_pars_fragment = "#ifdef USE_ENVMAP\n\tvec3 getIBLIrradiance( const in vec3 normal ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * worldNormal, 1.0 );\n\t\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\tvec3 getIBLRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness ) {\n\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\tvec3 reflectVec = reflect( - viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, envMapRotation * reflectVec, roughness );\n\t\t\treturn envMapColor.rgb * envMapIntensity;\n\t\t#else\n\t\t\treturn vec3( 0.0 );\n\t\t#endif\n\t}\n\t#ifdef USE_ANISOTROPY\n\t\tvec3 getIBLAnisotropyRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in vec3 bitangent, const in float anisotropy ) {\n\t\t\t#ifdef ENVMAP_TYPE_CUBE_UV\n\t\t\t\tvec3 bentNormal = cross( bitangent, viewDir );\n\t\t\t\tbentNormal = normalize( cross( bentNormal, bitangent ) );\n\t\t\t\tbentNormal = normalize( mix( bentNormal, normal, pow2( pow2( 1.0 - anisotropy * ( 1.0 - roughness ) ) ) ) );\n\t\t\t\treturn getIBLRadiance( viewDir, bentNormal, roughness );\n\t\t\t#else\n\t\t\t\treturn vec3( 0.0 );\n\t\t\t#endif\n\t\t}\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$lights_toon_fragment = "ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;";
var $3dd44ec8564e7230$var$lights_toon_pars_fragment = "varying vec3 vViewPosition;\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometryNormal, directLight.direction ) * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon";
var $3dd44ec8564e7230$var$lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;";
var $3dd44ec8564e7230$var$lights_phong_pars_fragment = "varying vec3 vViewPosition;\nstruct BlinnPhongMaterial {\n\tvec3 diffuseColor;\n\tvec3 specularColor;\n\tfloat specularShininess;\n\tfloat specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_BlinnPhong( directLight.direction, geometryViewDir, geometryNormal, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong";
var $3dd44ec8564e7230$var$lights_physical_fragment = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( nonPerturbedNormal ) ), abs( dFdy( nonPerturbedNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.roughness = max( roughnessFactor, 0.0525 );material.roughness += geometryRoughness;\nmaterial.roughness = min( material.roughness, 1.0 );\n#ifdef IOR\n\tmaterial.ior = ior;\n\t#ifdef USE_SPECULAR\n\t\tfloat specularIntensityFactor = specularIntensity;\n\t\tvec3 specularColorFactor = specularColor;\n\t\t#ifdef USE_SPECULAR_COLORMAP\n\t\t\tspecularColorFactor *= texture2D( specularColorMap, vSpecularColorMapUv ).rgb;\n\t\t#endif\n\t\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\t\tspecularIntensityFactor *= texture2D( specularIntensityMap, vSpecularIntensityMapUv ).a;\n\t\t#endif\n\t\tmaterial.specularF90 = mix( specularIntensityFactor, 1.0, metalnessFactor );\n\t#else\n\t\tfloat specularIntensityFactor = 1.0;\n\t\tvec3 specularColorFactor = vec3( 1.0 );\n\t\tmaterial.specularF90 = 1.0;\n\t#endif\n\tmaterial.specularColor = mix( min( pow2( ( material.ior - 1.0 ) / ( material.ior + 1.0 ) ) * specularColorFactor, vec3( 1.0 ) ) * specularIntensityFactor, diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.specularF90 = 1.0;\n#endif\n#ifdef USE_CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\tmaterial.clearcoatF0 = vec3( 0.04 );\n\tmaterial.clearcoatF90 = 1.0;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vClearcoatMapUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vClearcoatRoughnessMapUv ).y;\n\t#endif\n\tmaterial.clearcoat = saturate( material.clearcoat );\tmaterial.clearcoatRoughness = max( material.clearcoatRoughness, 0.0525 );\n\tmaterial.clearcoatRoughness += geometryRoughness;\n\tmaterial.clearcoatRoughness = min( material.clearcoatRoughness, 1.0 );\n#endif\n#ifdef USE_DISPERSION\n\tmaterial.dispersion = dispersion;\n#endif\n#ifdef USE_IRIDESCENCE\n\tmaterial.iridescence = iridescence;\n\tmaterial.iridescenceIOR = iridescenceIOR;\n\t#ifdef USE_IRIDESCENCEMAP\n\t\tmaterial.iridescence *= texture2D( iridescenceMap, vIridescenceMapUv ).r;\n\t#endif\n\t#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\t\tmaterial.iridescenceThickness = (iridescenceThicknessMaximum - iridescenceThicknessMinimum) * texture2D( iridescenceThicknessMap, vIridescenceThicknessMapUv ).g + iridescenceThicknessMinimum;\n\t#else\n\t\tmaterial.iridescenceThickness = iridescenceThicknessMaximum;\n\t#endif\n#endif\n#ifdef USE_SHEEN\n\tmaterial.sheenColor = sheenColor;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tmaterial.sheenColor *= texture2D( sheenColorMap, vSheenColorMapUv ).rgb;\n\t#endif\n\tmaterial.sheenRoughness = clamp( sheenRoughness, 0.07, 1.0 );\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tmaterial.sheenRoughness *= texture2D( sheenRoughnessMap, vSheenRoughnessMapUv ).a;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\t#ifdef USE_ANISOTROPYMAP\n\t\tmat2 anisotropyMat = mat2( anisotropyVector.x, anisotropyVector.y, - anisotropyVector.y, anisotropyVector.x );\n\t\tvec3 anisotropyPolar = texture2D( anisotropyMap, vAnisotropyMapUv ).rgb;\n\t\tvec2 anisotropyV = anisotropyMat * normalize( 2.0 * anisotropyPolar.rg - vec2( 1.0 ) ) * anisotropyPolar.b;\n\t#else\n\t\tvec2 anisotropyV = anisotropyVector;\n\t#endif\n\tmaterial.anisotropy = length( anisotropyV );\n\tif( material.anisotropy == 0.0 ) {\n\t\tanisotropyV = vec2( 1.0, 0.0 );\n\t} else {\n\t\tanisotropyV /= material.anisotropy;\n\t\tmaterial.anisotropy = saturate( material.anisotropy );\n\t}\n\tmaterial.alphaT = mix( pow2( material.roughness ), 1.0, pow2( material.anisotropy ) );\n\tmaterial.anisotropyT = tbn[ 0 ] * anisotropyV.x + tbn[ 1 ] * anisotropyV.y;\n\tmaterial.anisotropyB = tbn[ 1 ] * anisotropyV.x - tbn[ 0 ] * anisotropyV.y;\n#endif";
var $3dd44ec8564e7230$var$lights_physical_pars_fragment = "struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat roughness;\n\tvec3 specularColor;\n\tfloat specularF90;\n\tfloat dispersion;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat clearcoat;\n\t\tfloat clearcoatRoughness;\n\t\tvec3 clearcoatF0;\n\t\tfloat clearcoatF90;\n\t#endif\n\t#ifdef USE_IRIDESCENCE\n\t\tfloat iridescence;\n\t\tfloat iridescenceIOR;\n\t\tfloat iridescenceThickness;\n\t\tvec3 iridescenceFresnel;\n\t\tvec3 iridescenceF0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tvec3 sheenColor;\n\t\tfloat sheenRoughness;\n\t#endif\n\t#ifdef IOR\n\t\tfloat ior;\n\t#endif\n\t#ifdef USE_TRANSMISSION\n\t\tfloat transmission;\n\t\tfloat transmissionAlpha;\n\t\tfloat thickness;\n\t\tfloat attenuationDistance;\n\t\tvec3 attenuationColor;\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat anisotropy;\n\t\tfloat alphaT;\n\t\tvec3 anisotropyT;\n\t\tvec3 anisotropyB;\n\t#endif\n};\nvec3 clearcoatSpecularDirect = vec3( 0.0 );\nvec3 clearcoatSpecularIndirect = vec3( 0.0 );\nvec3 sheenSpecularDirect = vec3( 0.0 );\nvec3 sheenSpecularIndirect = vec3(0.0 );\nvec3 Schlick_to_F0( const in vec3 f, const in float f90, const in float dotVH ) {\n    float x = clamp( 1.0 - dotVH, 0.0, 1.0 );\n    float x2 = x * x;\n    float x5 = clamp( x * x2 * x2, 0.0, 0.9999 );\n    return ( f - vec3( f90 ) * x5 ) / ( 1.0 - x5 );\n}\nfloat V_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\n#ifdef USE_ANISOTROPY\n\tfloat V_GGX_SmithCorrelated_Anisotropic( const in float alphaT, const in float alphaB, const in float dotTV, const in float dotBV, const in float dotTL, const in float dotBL, const in float dotNV, const in float dotNL ) {\n\t\tfloat gv = dotNL * length( vec3( alphaT * dotTV, alphaB * dotBV, dotNV ) );\n\t\tfloat gl = dotNV * length( vec3( alphaT * dotTL, alphaB * dotBL, dotNL ) );\n\t\tfloat v = 0.5 / ( gv + gl );\n\t\treturn saturate(v);\n\t}\n\tfloat D_GGX_Anisotropic( const in float alphaT, const in float alphaB, const in float dotNH, const in float dotTH, const in float dotBH ) {\n\t\tfloat a2 = alphaT * alphaB;\n\t\thighp vec3 v = vec3( alphaB * dotTH, alphaT * dotBH, a2 * dotNH );\n\t\thighp float v2 = dot( v, v );\n\t\tfloat w2 = a2 / v2;\n\t\treturn RECIPROCAL_PI * a2 * pow2 ( w2 );\n\t}\n#endif\n#ifdef USE_CLEARCOAT\n\tvec3 BRDF_GGX_Clearcoat( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material) {\n\t\tvec3 f0 = material.clearcoatF0;\n\t\tfloat f90 = material.clearcoatF90;\n\t\tfloat roughness = material.clearcoatRoughness;\n\t\tfloat alpha = pow2( roughness );\n\t\tvec3 halfDir = normalize( lightDir + viewDir );\n\t\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\t\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\t\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\t\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\t\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t\treturn F * ( V * D );\n\t}\n#endif\nvec3 BRDF_GGX( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, const in PhysicalMaterial material ) {\n\tvec3 f0 = material.specularColor;\n\tfloat f90 = material.specularF90;\n\tfloat roughness = material.roughness;\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotVH = saturate( dot( viewDir, halfDir ) );\n\tvec3 F = F_Schlick( f0, f90, dotVH );\n\t#ifdef USE_IRIDESCENCE\n\t\tF = mix( F, material.iridescenceFresnel, material.iridescence );\n\t#endif\n\t#ifdef USE_ANISOTROPY\n\t\tfloat dotTL = dot( material.anisotropyT, lightDir );\n\t\tfloat dotTV = dot( material.anisotropyT, viewDir );\n\t\tfloat dotTH = dot( material.anisotropyT, halfDir );\n\t\tfloat dotBL = dot( material.anisotropyB, lightDir );\n\t\tfloat dotBV = dot( material.anisotropyB, viewDir );\n\t\tfloat dotBH = dot( material.anisotropyB, halfDir );\n\t\tfloat V = V_GGX_SmithCorrelated_Anisotropic( material.alphaT, alpha, dotTV, dotBV, dotTL, dotBL, dotNV, dotNL );\n\t\tfloat D = D_GGX_Anisotropic( material.alphaT, alpha, dotNH, dotTH, dotBH );\n\t#else\n\t\tfloat V = V_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\t\tfloat D = D_GGX( alpha, dotNH );\n\t#endif\n\treturn F * ( V * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\n\tfloat dotNV = saturate( dot( N, V ) );\n\tvec2 uv = vec2( roughness, sqrt( 1.0 - dotNV ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.8543985 + ( 0.4965155 + 0.0145206 * y ) * y;\n\tfloat b = 3.4175940 + ( 4.1616724 + y ) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = ( x > 0.0 ) ? v : 0.5 * inversesqrt( max( 1.0 - x * x, 1e-7 ) ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( coords[ 2 ] );\n\tcoords[ 3 ] = normalize( coords[ 3 ] );\n\tvec3 vectorFormFactor = vec3( 0.0 );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\n\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\n\tfloat result = LTC_ClippedSphereFormFactor( vectorFormFactor );\n\treturn vec3( result );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie( float roughness, float dotNH ) {\n\tfloat alpha = pow2( roughness );\n\tfloat invAlpha = 1.0 / alpha;\n\tfloat cos2h = dotNH * dotNH;\n\tfloat sin2h = max( 1.0 - cos2h, 0.0078125 );\n\treturn ( 2.0 + invAlpha ) * pow( sin2h, invAlpha * 0.5 ) / ( 2.0 * PI );\n}\nfloat V_Neubelt( float dotNV, float dotNL ) {\n\treturn saturate( 1.0 / ( 4.0 * ( dotNL + dotNV - dotNL * dotNV ) ) );\n}\nvec3 BRDF_Sheen( const in vec3 lightDir, const in vec3 viewDir, const in vec3 normal, vec3 sheenColor, const in float sheenRoughness ) {\n\tvec3 halfDir = normalize( lightDir + viewDir );\n\tfloat dotNL = saturate( dot( normal, lightDir ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat D = D_Charlie( sheenRoughness, dotNH );\n\tfloat V = V_Neubelt( dotNV, dotNL );\n\treturn sheenColor * ( D * V );\n}\n#endif\nfloat IBLSheenBRDF( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat r2 = roughness * roughness;\n\tfloat a = roughness < 0.25 ? -339.2 * r2 + 161.4 * roughness - 25.9 : -8.48 * r2 + 14.3 * roughness - 9.95;\n\tfloat b = roughness < 0.25 ? 44.0 * r2 - 23.7 * roughness + 3.26 : 1.97 * r2 - 3.27 * roughness + 0.72;\n\tfloat DG = exp( a * dotNV + b ) + ( roughness < 0.25 ? 0.0 : 0.1 * ( roughness - 0.25 ) );\n\treturn saturate( DG * RECIPROCAL_PI );\n}\nvec2 DFGApprox( const in vec3 normal, const in vec3 viewDir, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n\tvec4 r = roughness * c0 + c1;\n\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n\tvec2 fab = vec2( - 1.04, 1.04 ) * a004 + r.zw;\n\treturn fab;\n}\nvec3 EnvironmentBRDF( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness ) {\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\treturn specularColor * fab.x + specularF90 * fab.y;\n}\n#ifdef USE_IRIDESCENCE\nvoid computeMultiscatteringIridescence( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float iridescence, const in vec3 iridescenceF0, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#else\nvoid computeMultiscattering( const in vec3 normal, const in vec3 viewDir, const in vec3 specularColor, const in float specularF90, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n#endif\n\tvec2 fab = DFGApprox( normal, viewDir, roughness );\n\t#ifdef USE_IRIDESCENCE\n\t\tvec3 Fr = mix( specularColor, iridescenceF0, iridescence );\n\t#else\n\t\tvec3 Fr = specularColor;\n\t#endif\n\tvec3 FssEss = Fr * fab.x + specularF90 * fab.y;\n\tfloat Ess = fab.x + fab.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = Fr + ( 1.0 - Fr ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometryNormal;\n\t\tvec3 viewDir = geometryViewDir;\n\t\tvec3 position = geometryPosition;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.roughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos + halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos - halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos - halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos + halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tvec4 t1 = texture2D( ltc_1, uv );\n\t\tvec4 t2 = texture2D( ltc_2, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3( t1.x, 0, t1.y ),\n\t\t\tvec3(    0, 1,    0 ),\n\t\t\tvec3( t1.z, 0, t1.w )\n\t\t);\n\t\tvec3 fresnel = ( material.specularColor * t2.x + ( vec3( 1.0 ) - material.specularColor ) * t2.y );\n\t\treflectedLight.directSpecular += lightColor * fresnel * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1.0 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometryNormal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNLcc = saturate( dot( geometryClearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = dotNLcc * directLight.color;\n\t\tclearcoatSpecularDirect += ccIrradiance * BRDF_GGX_Clearcoat( directLight.direction, geometryViewDir, geometryClearcoatNormal, material );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularDirect += irradiance * BRDF_Sheen( directLight.direction, geometryViewDir, geometryNormal, material.sheenColor, material.sheenRoughness );\n\t#endif\n\treflectedLight.directSpecular += irradiance * BRDF_GGX( directLight.direction, geometryViewDir, geometryNormal, material );\n\treflectedLight.directDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in vec3 geometryPosition, const in vec3 geometryNormal, const in vec3 geometryViewDir, const in vec3 geometryClearcoatNormal, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatSpecularIndirect += clearcoatRadiance * EnvironmentBRDF( geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness );\n\t#endif\n\t#ifdef USE_SHEEN\n\t\tsheenSpecularIndirect += irradiance * material.sheenColor * IBLSheenBRDF( geometryNormal, geometryViewDir, material.sheenRoughness );\n\t#endif\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\t#ifdef USE_IRIDESCENCE\n\t\tcomputeMultiscatteringIridescence( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.iridescence, material.iridescenceFresnel, material.roughness, singleScattering, multiScattering );\n\t#else\n\t\tcomputeMultiscattering( geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness, singleScattering, multiScattering );\n\t#endif\n\tvec3 totalScattering = singleScattering + multiScattering;\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - max( max( totalScattering.r, totalScattering.g ), totalScattering.b ) );\n\treflectedLight.indirectSpecular += radiance * singleScattering;\n\treflectedLight.indirectSpecular += multiScattering * cosineWeightedIrradiance;\n\treflectedLight.indirectDiffuse += diffuse * cosineWeightedIrradiance;\n}\n#define RE_Direct\t\t\t\tRE_Direct_Physical\n#define RE_Direct_RectArea\t\tRE_Direct_RectArea_Physical\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular\t\tRE_IndirectSpecular_Physical\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}";
var $3dd44ec8564e7230$var$lights_fragment_begin = "\nvec3 geometryPosition = - vViewPosition;\nvec3 geometryNormal = normal;\nvec3 geometryViewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\nvec3 geometryClearcoatNormal = vec3( 0.0 );\n#ifdef USE_CLEARCOAT\n\tgeometryClearcoatNormal = clearcoatNormal;\n#endif\n#ifdef USE_IRIDESCENCE\n\tfloat dotNVi = saturate( dot( normal, geometryViewDir ) );\n\tif ( material.iridescenceThickness == 0.0 ) {\n\t\tmaterial.iridescence = 0.0;\n\t} else {\n\t\tmaterial.iridescence = saturate( material.iridescence );\n\t}\n\tif ( material.iridescence > 0.0 ) {\n\t\tmaterial.iridescenceFresnel = evalIridescence( 1.0, material.iridescenceIOR, dotNVi, material.iridescenceThickness, material.specularColor );\n\t\tmaterial.iridescenceF0 = Schlick_to_F0( material.iridescenceFresnel, 1.0, dotNVi );\n\t}\n#endif\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\tPointLight pointLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointLightInfo( pointLight, geometryPosition, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowIntensity, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\tvec4 spotColor;\n\tvec3 spotLightCoord;\n\tbool inSpotLightMap;\n\t#if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotLightInfo( spotLight, geometryPosition, directLight );\n\t\t#if ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#define SPOT_LIGHT_MAP_INDEX UNROLLED_LOOP_INDEX\n\t\t#elif ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t#define SPOT_LIGHT_MAP_INDEX NUM_SPOT_LIGHT_MAPS\n\t\t#else\n\t\t#define SPOT_LIGHT_MAP_INDEX ( UNROLLED_LOOP_INDEX - NUM_SPOT_LIGHT_SHADOWS + NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS )\n\t\t#endif\n\t\t#if ( SPOT_LIGHT_MAP_INDEX < NUM_SPOT_LIGHT_MAPS )\n\t\t\tspotLightCoord = vSpotLightCoord[ i ].xyz / vSpotLightCoord[ i ].w;\n\t\t\tinSpotLightMap = all( lessThan( abs( spotLightCoord * 2. - 1. ), vec3( 1.0 ) ) );\n\t\t\tspotColor = texture2D( spotLightMap[ SPOT_LIGHT_MAP_INDEX ], spotLightCoord.xy );\n\t\t\tdirectLight.color = inSpotLightMap ? directLight.color * spotColor.rgb : directLight.color;\n\t\t#endif\n\t\t#undef SPOT_LIGHT_MAP_INDEX\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowIntensity, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\t#if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLightShadow;\n\t#endif\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalLightInfo( directionalLight, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= ( directLight.visible && receiveShadow ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowIntensity, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 iblIrradiance = vec3( 0.0 );\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#if defined( USE_LIGHT_PROBES )\n\t\tirradiance += getLightProbeIrradiance( lightProbe, geometryNormal );\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometryNormal );\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if defined( RE_IndirectSpecular )\n\tvec3 radiance = vec3( 0.0 );\n\tvec3 clearcoatRadiance = vec3( 0.0 );\n#endif";
var $3dd44ec8564e7230$var$lights_fragment_maps = "#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\tvec3 lightMapIrradiance = lightMapTexel.rgb * lightMapIntensity;\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getIBLIrradiance( geometryNormal );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\t#ifdef USE_ANISOTROPY\n\t\tradiance += getIBLAnisotropyRadiance( geometryViewDir, geometryNormal, material.roughness, material.anisotropyB, material.anisotropy );\n\t#else\n\t\tradiance += getIBLRadiance( geometryViewDir, geometryNormal, material.roughness );\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tclearcoatRadiance += getIBLRadiance( geometryViewDir, geometryClearcoatNormal, material.clearcoatRoughness );\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$lights_fragment_end = "#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometryPosition, geometryNormal, geometryViewDir, geometryClearcoatNormal, material, reflectedLight );\n#endif";
var $3dd44ec8564e7230$var$logdepthbuf_fragment = "#if defined( USE_LOGDEPTHBUF )\n\tgl_FragDepth = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif";
var $3dd44ec8564e7230$var$logdepthbuf_pars_fragment = "#if defined( USE_LOGDEPTHBUF )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif";
var $3dd44ec8564e7230$var$logdepthbuf_pars_vertex = "#ifdef USE_LOGDEPTHBUF\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif";
var $3dd44ec8564e7230$var$logdepthbuf_vertex = "#ifdef USE_LOGDEPTHBUF\n\tvFragDepth = 1.0 + gl_Position.w;\n\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n#endif";
var $3dd44ec8564e7230$var$map_fragment = "#ifdef USE_MAP\n\tvec4 sampledDiffuseColor = texture2D( map, vMapUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\tsampledDiffuseColor = sRGBTransferEOTF( sampledDiffuseColor );\n\t#endif\n\tdiffuseColor *= sampledDiffuseColor;\n#endif";
var $3dd44ec8564e7230$var$map_pars_fragment = "#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif";
var $3dd44ec8564e7230$var$map_particle_fragment = "#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t#if defined( USE_POINTS_UV )\n\t\tvec2 uv = vUv;\n\t#else\n\t\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tdiffuseColor *= texture2D( map, uv );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif";
var $3dd44ec8564e7230$var$map_particle_pars_fragment = "#if defined( USE_POINTS_UV )\n\tvarying vec2 vUv;\n#else\n\t#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\t\tuniform mat3 uvTransform;\n\t#endif\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif";
var $3dd44ec8564e7230$var$metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vMetalnessMapUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif";
var $3dd44ec8564e7230$var$metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif";
var $3dd44ec8564e7230$var$morphinstance_vertex = "#ifdef USE_INSTANCING_MORPH\n\tfloat morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\tfloat morphTargetBaseInfluence = texelFetch( morphTexture, ivec2( 0, gl_InstanceID ), 0 ).r;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tmorphTargetInfluences[i] =  texelFetch( morphTexture, ivec2( i + 1, gl_InstanceID ), 0 ).r;\n\t}\n#endif";
var $3dd44ec8564e7230$var$morphcolor_vertex = "#if defined( USE_MORPHCOLORS )\n\tvColor *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\t#if defined( USE_COLOR_ALPHA )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ) * morphTargetInfluences[ i ];\n\t\t#elif defined( USE_COLOR )\n\t\t\tif ( morphTargetInfluences[ i ] != 0.0 ) vColor += getMorph( gl_VertexID, i, 2 ).rgb * morphTargetInfluences[ i ];\n\t\t#endif\n\t}\n#endif";
var $3dd44ec8564e7230$var$morphnormal_vertex = "#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tif ( morphTargetInfluences[ i ] != 0.0 ) objectNormal += getMorph( gl_VertexID, i, 1 ).xyz * morphTargetInfluences[ i ];\n\t}\n#endif";
var $3dd44ec8564e7230$var$morphtarget_pars_vertex = "#ifdef USE_MORPHTARGETS\n\t#ifndef USE_INSTANCING_MORPH\n\t\tuniform float morphTargetBaseInfluence;\n\t\tuniform float morphTargetInfluences[ MORPHTARGETS_COUNT ];\n\t#endif\n\tuniform sampler2DArray morphTargetsTexture;\n\tuniform ivec2 morphTargetsTextureSize;\n\tvec4 getMorph( const in int vertexIndex, const in int morphTargetIndex, const in int offset ) {\n\t\tint texelIndex = vertexIndex * MORPHTARGETS_TEXTURE_STRIDE + offset;\n\t\tint y = texelIndex / morphTargetsTextureSize.x;\n\t\tint x = texelIndex - y * morphTargetsTextureSize.x;\n\t\tivec3 morphUV = ivec3( x, y, morphTargetIndex );\n\t\treturn texelFetch( morphTargetsTexture, morphUV, 0 );\n\t}\n#endif";
var $3dd44ec8564e7230$var$morphtarget_vertex = "#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\tfor ( int i = 0; i < MORPHTARGETS_COUNT; i ++ ) {\n\t\tif ( morphTargetInfluences[ i ] != 0.0 ) transformed += getMorph( gl_VertexID, i, 0 ).xyz * morphTargetInfluences[ i ];\n\t}\n#endif";
var $3dd44ec8564e7230$var$normal_fragment_begin = "float faceDirection = gl_FrontFacing ? 1.0 : - 1.0;\n#ifdef FLAT_SHADED\n\tvec3 fdx = dFdx( vViewPosition );\n\tvec3 fdy = dFdy( vViewPosition );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal *= faceDirection;\n\t#endif\n#endif\n#if defined( USE_NORMALMAP_TANGENTSPACE ) || defined( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY )\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn = getTangentFrame( - vViewPosition, normal,\n\t\t#if defined( USE_NORMALMAP )\n\t\t\tvNormalMapUv\n\t\t#elif defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tvClearcoatNormalMapUv\n\t\t#else\n\t\t\tvUv\n\t\t#endif\n\t\t);\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn[0] *= faceDirection;\n\t\ttbn[1] *= faceDirection;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\t#ifdef USE_TANGENT\n\t\tmat3 tbn2 = mat3( normalize( vTangent ), normalize( vBitangent ), normal );\n\t#else\n\t\tmat3 tbn2 = getTangentFrame( - vViewPosition, normal, vClearcoatNormalMapUv );\n\t#endif\n\t#if defined( DOUBLE_SIDED ) && ! defined( FLAT_SHADED )\n\t\ttbn2[0] *= faceDirection;\n\t\ttbn2[1] *= faceDirection;\n\t#endif\n#endif\nvec3 nonPerturbedNormal = normal;";
var $3dd44ec8564e7230$var$normal_fragment_maps = "#ifdef USE_NORMALMAP_OBJECTSPACE\n\tnormal = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\t#ifdef FLIP_SIDED\n\t\tnormal = - normal;\n\t#endif\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * faceDirection;\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( USE_NORMALMAP_TANGENTSPACE )\n\tvec3 mapN = texture2D( normalMap, vNormalMapUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\tnormal = normalize( tbn * mapN );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( - vViewPosition, normal, dHdxy_fwd(), faceDirection );\n#endif";
var $3dd44ec8564e7230$var$normal_pars_fragment = "#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$normal_pars_vertex = "#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n\t#ifdef USE_TANGENT\n\t\tvarying vec3 vTangent;\n\t\tvarying vec3 vBitangent;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$normal_vertex = "#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n\t#ifdef USE_TANGENT\n\t\tvTangent = normalize( transformedTangent );\n\t\tvBitangent = normalize( cross( vNormal, vTangent ) * tangent.w );\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$normalmap_pars_fragment = "#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef USE_NORMALMAP_OBJECTSPACE\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( USE_NORMALMAP_TANGENTSPACE ) || defined ( USE_CLEARCOAT_NORMALMAP ) || defined( USE_ANISOTROPY ) )\n\tmat3 getTangentFrame( vec3 eye_pos, vec3 surf_norm, vec2 uv ) {\n\t\tvec3 q0 = dFdx( eye_pos.xyz );\n\t\tvec3 q1 = dFdy( eye_pos.xyz );\n\t\tvec2 st0 = dFdx( uv.st );\n\t\tvec2 st1 = dFdy( uv.st );\n\t\tvec3 N = surf_norm;\n\t\tvec3 q1perp = cross( q1, N );\n\t\tvec3 q0perp = cross( N, q0 );\n\t\tvec3 T = q1perp * st0.x + q0perp * st1.x;\n\t\tvec3 B = q1perp * st0.y + q0perp * st1.y;\n\t\tfloat det = max( dot( T, T ), dot( B, B ) );\n\t\tfloat scale = ( det == 0.0 ) ? 0.0 : inversesqrt( det );\n\t\treturn mat3( T * scale, B * scale, N );\n\t}\n#endif";
var $3dd44ec8564e7230$var$clearcoat_normal_fragment_begin = "#ifdef USE_CLEARCOAT\n\tvec3 clearcoatNormal = nonPerturbedNormal;\n#endif";
var $3dd44ec8564e7230$var$clearcoat_normal_fragment_maps = "#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vClearcoatNormalMapUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\tclearcoatNormal = normalize( tbn2 * clearcoatMapN );\n#endif";
var $3dd44ec8564e7230$var$clearcoat_pars_fragment = "#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif";
var $3dd44ec8564e7230$var$iridescence_pars_fragment = "#ifdef USE_IRIDESCENCEMAP\n\tuniform sampler2D iridescenceMap;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform sampler2D iridescenceThicknessMap;\n#endif";
var $3dd44ec8564e7230$var$opaque_fragment = "#ifdef OPAQUE\ndiffuseColor.a = 1.0;\n#endif\n#ifdef USE_TRANSMISSION\ndiffuseColor.a *= material.transmissionAlpha;\n#endif\ngl_FragColor = vec4( outgoingLight, diffuseColor.a );";
var $3dd44ec8564e7230$var$packing = "vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 2.0 * rgb.xyz - 1.0;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;const float ShiftRight8 = 1. / 256.;\nconst float Inv255 = 1. / 255.;\nconst vec4 PackFactors = vec4( 1.0, 256.0, 256.0 * 256.0, 256.0 * 256.0 * 256.0 );\nconst vec2 UnpackFactors2 = vec2( UnpackDownscale, 1.0 / PackFactors.g );\nconst vec3 UnpackFactors3 = vec3( UnpackDownscale / PackFactors.rg, 1.0 / PackFactors.b );\nconst vec4 UnpackFactors4 = vec4( UnpackDownscale / PackFactors.rgb, 1.0 / PackFactors.a );\nvec4 packDepthToRGBA( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec4( 0., 0., 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec4( 1., 1., 1., 1. );\n\tfloat vuf;\n\tfloat af = modf( v * PackFactors.a, vuf );\n\tfloat bf = modf( vuf * ShiftRight8, vuf );\n\tfloat gf = modf( vuf * ShiftRight8, vuf );\n\treturn vec4( vuf * Inv255, gf * PackUpscale, bf * PackUpscale, af );\n}\nvec3 packDepthToRGB( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec3( 0., 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec3( 1., 1., 1. );\n\tfloat vuf;\n\tfloat bf = modf( v * PackFactors.b, vuf );\n\tfloat gf = modf( vuf * ShiftRight8, vuf );\n\treturn vec3( vuf * Inv255, gf * PackUpscale, bf );\n}\nvec2 packDepthToRG( const in float v ) {\n\tif( v <= 0.0 )\n\t\treturn vec2( 0., 0. );\n\tif( v >= 1.0 )\n\t\treturn vec2( 1., 1. );\n\tfloat vuf;\n\tfloat gf = modf( v * 256., vuf );\n\treturn vec2( vuf * Inv255, gf );\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors4 );\n}\nfloat unpackRGBToDepth( const in vec3 v ) {\n\treturn dot( v, UnpackFactors3 );\n}\nfloat unpackRGToDepth( const in vec2 v ) {\n\treturn v.r * UnpackFactors2.r + v.g * UnpackFactors2.g;\n}\nvec4 pack2HalfToRGBA( const in vec2 v ) {\n\tvec4 r = vec4( v.x, fract( v.x * 255.0 ), v.y, fract( v.y * 255.0 ) );\n\treturn vec4( r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w );\n}\nvec2 unpackRGBATo2Half( const in vec4 v ) {\n\treturn vec2( v.x + ( v.y / 255.0 ), v.z + ( v.w / 255.0 ) );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn depth * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( ( near + viewZ ) * far ) / ( ( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float depth, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * depth - far );\n}";
var $3dd44ec8564e7230$var$premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif";
var $3dd44ec8564e7230$var$project_vertex = "vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_BATCHING\n\tmvPosition = batchingMatrix * mvPosition;\n#endif\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;";
var $3dd44ec8564e7230$var$dithering_fragment = "#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif";
var $3dd44ec8564e7230$var$dithering_pars_fragment = "#ifdef DITHERING\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif";
var $3dd44ec8564e7230$var$roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vRoughnessMapUv );\n\troughnessFactor *= texelRoughness.g;\n#endif";
var $3dd44ec8564e7230$var$roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif";
var $3dd44ec8564e7230$var$shadowmap_pars_fragment = "#if NUM_SPOT_LIGHT_COORDS > 0\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#if NUM_SPOT_LIGHT_MAPS > 0\n\tuniform sampler2D spotLightMap[ NUM_SPOT_LIGHT_MAPS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tvec2 texture2DDistribution( sampler2D shadow, vec2 uv ) {\n\t\treturn unpackRGBATo2Half( texture2D( shadow, uv ) );\n\t}\n\tfloat VSMShadow (sampler2D shadow, vec2 uv, float compare ){\n\t\tfloat occlusion = 1.0;\n\t\tvec2 distribution = texture2DDistribution( shadow, uv );\n\t\tfloat hard_shadow = step( compare , distribution.x );\n\t\tif (hard_shadow != 1.0 ) {\n\t\t\tfloat distance = compare - distribution.x ;\n\t\t\tfloat variance = max( 0.00000, distribution.y * distribution.y );\n\t\t\tfloat softness_probability = variance / (variance + distance * distance );\t\t\tsoftness_probability = clamp( ( softness_probability - 0.3 ) / ( 0.95 - 0.3 ), 0.0, 1.0 );\t\t\tocclusion = clamp( max( hard_shadow, softness_probability ), 0.0, 1.0 );\n\t\t}\n\t\treturn occlusion;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbool inFrustum = shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0;\n\t\tbool frustumTest = inFrustum && shadowCoord.z <= 1.0;\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tfloat dx2 = dx0 / 2.0;\n\t\t\tfloat dy2 = dy0 / 2.0;\n\t\t\tfloat dx3 = dx1 / 2.0;\n\t\t\tfloat dy3 = dy1 / 2.0;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy2 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx2, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx3, dy3 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 17.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx = texelSize.x;\n\t\t\tfloat dy = texelSize.y;\n\t\t\tvec2 uv = shadowCoord.xy;\n\t\t\tvec2 f = fract( uv * shadowMapSize + 0.5 );\n\t\t\tuv -= f * texelSize;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, uv, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( dx, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + vec2( 0.0, dy ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, uv + texelSize, shadowCoord.z ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 0.0 ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( -dx, dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, dy ), shadowCoord.z ),\n\t\t\t\t\t f.x ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( 0.0, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( 0.0, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( texture2DCompare( shadowMap, uv + vec2( dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t texture2DCompare( shadowMap, uv + vec2( dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t f.y ) +\n\t\t\t\tmix( mix( texture2DCompare( shadowMap, uv + vec2( -dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, -dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t mix( texture2DCompare( shadowMap, uv + vec2( -dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  texture2DCompare( shadowMap, uv + vec2( 2.0 * dx, 2.0 * dy ), shadowCoord.z ),\n\t\t\t\t\t\t  f.x ),\n\t\t\t\t\t f.y )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_VSM )\n\t\t\tshadow = VSMShadow( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#else\n\t\t\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n\t\t#endif\n\t\t}\n\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t}\n\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\n\t\tvec3 absV = abs( v );\n\t\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n\t\tabsV *= scaleToCube;\n\t\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n\t\tvec2 planar = v.xy;\n\t\tfloat almostATexel = 1.5 * texelSizeY;\n\t\tfloat almostOne = 1.0 - almostATexel;\n\t\tif ( absV.z >= almostOne ) {\n\t\t\tif ( v.z > 0.0 )\n\t\t\t\tplanar.x = 4.0 - v.x;\n\t\t} else if ( absV.x >= almostOne ) {\n\t\t\tfloat signX = sign( v.x );\n\t\t\tplanar.x = v.z * signX + 2.0 * signX;\n\t\t} else if ( absV.y >= almostOne ) {\n\t\t\tfloat signY = sign( v.y );\n\t\t\tplanar.x = v.x + 2.0 * signY + 2.0;\n\t\t\tplanar.y = v.z * signY - 2.0;\n\t\t}\n\t\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n\t}\n\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tfloat shadow = 1.0;\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\t\n\t\tfloat lightToPositionLength = length( lightToPosition );\n\t\tif ( lightToPositionLength - shadowCameraFar <= 0.0 && lightToPositionLength - shadowCameraNear >= 0.0 ) {\n\t\t\tfloat dp = ( lightToPositionLength - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\t\tdp += shadowBias;\n\t\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\t\tshadow = (\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t\t) * ( 1.0 / 9.0 );\n\t\t\t#else\n\t\t\t\tshadow = texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t\t#endif\n\t\t}\n\t\treturn mix( 1.0, shadow, shadowIntensity );\n\t}\n#endif";
var $3dd44ec8564e7230$var$shadowmap_pars_vertex = "#if NUM_SPOT_LIGHT_COORDS > 0\n\tuniform mat4 spotLightMatrix[ NUM_SPOT_LIGHT_COORDS ];\n\tvarying vec4 vSpotLightCoord[ NUM_SPOT_LIGHT_COORDS ];\n#endif\n#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHT_SHADOWS ];\n\t\tstruct DirectionalLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform DirectionalLightShadow directionalLightShadows[ NUM_DIR_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t\tstruct SpotLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t};\n\t\tuniform SpotLightShadow spotLightShadows[ NUM_SPOT_LIGHT_SHADOWS ];\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHT_SHADOWS ];\n\t\tstruct PointLightShadow {\n\t\t\tfloat shadowIntensity;\n\t\t\tfloat shadowBias;\n\t\t\tfloat shadowNormalBias;\n\t\t\tfloat shadowRadius;\n\t\t\tvec2 shadowMapSize;\n\t\t\tfloat shadowCameraNear;\n\t\t\tfloat shadowCameraFar;\n\t\t};\n\t\tuniform PointLightShadow pointLightShadows[ NUM_POINT_LIGHT_SHADOWS ];\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$shadowmap_vertex = "#if ( defined( USE_SHADOWMAP ) && ( NUM_DIR_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0 ) ) || ( NUM_SPOT_LIGHT_COORDS > 0 )\n\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\tvec4 shadowWorldPosition;\n#endif\n#if defined( USE_SHADOWMAP )\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t#endif\n#endif\n#if NUM_SPOT_LIGHT_COORDS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_COORDS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition;\n\t\t#if ( defined( USE_SHADOWMAP ) && UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\t\tshadowWorldPosition.xyz += shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias;\n\t\t#endif\n\t\tvSpotLightCoord[ i ] = spotLightMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n#endif";
var $3dd44ec8564e7230$var$shadowmask_pars_fragment = "float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\tDirectionalLightShadow directionalLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tdirectionalLight = directionalLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowIntensity, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\tSpotLightShadow spotLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tspotLight = spotLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowIntensity, spotLight.shadowBias, spotLight.shadowRadius, vSpotLightCoord[ i ] ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\tPointLightShadow pointLight;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tpointLight = pointLightShadows[ i ];\n\t\tshadow *= receiveShadow ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowIntensity, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#endif\n\treturn shadow;\n}";
var $3dd44ec8564e7230$var$skinbase_vertex = "#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";
var $3dd44ec8564e7230$var$skinning_pars_vertex = "#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\tuniform highp sampler2D boneTexture;\n\tmat4 getBoneMatrix( const in float i ) {\n\t\tint size = textureSize( boneTexture, 0 ).x;\n\t\tint j = int( i ) * 4;\n\t\tint x = j % size;\n\t\tint y = j / size;\n\t\tvec4 v1 = texelFetch( boneTexture, ivec2( x, y ), 0 );\n\t\tvec4 v2 = texelFetch( boneTexture, ivec2( x + 1, y ), 0 );\n\t\tvec4 v3 = texelFetch( boneTexture, ivec2( x + 2, y ), 0 );\n\t\tvec4 v4 = texelFetch( boneTexture, ivec2( x + 3, y ), 0 );\n\t\treturn mat4( v1, v2, v3, v4 );\n\t}\n#endif";
var $3dd44ec8564e7230$var$skinning_vertex = "#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif";
var $3dd44ec8564e7230$var$skinnormal_vertex = "#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n\t#ifdef USE_TANGENT\n\t\tobjectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#endif\n#endif";
var $3dd44ec8564e7230$var$specularmap_fragment = "float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vSpecularMapUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif";
var $3dd44ec8564e7230$var$specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif";
var $3dd44ec8564e7230$var$tonemapping_fragment = "#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif";
var $3dd44ec8564e7230$var$tonemapping_pars_fragment = "#ifndef saturate\n#define saturate( a ) clamp( a, 0.0, 1.0 )\n#endif\nuniform float toneMappingExposure;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn saturate( toneMappingExposure * color );\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 CineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\nvec3 RRTAndODTFit( vec3 v ) {\n\tvec3 a = v * ( v + 0.0245786 ) - 0.000090537;\n\tvec3 b = v * ( 0.983729 * v + 0.4329510 ) + 0.238081;\n\treturn a / b;\n}\nvec3 ACESFilmicToneMapping( vec3 color ) {\n\tconst mat3 ACESInputMat = mat3(\n\t\tvec3( 0.59719, 0.07600, 0.02840 ),\t\tvec3( 0.35458, 0.90834, 0.13383 ),\n\t\tvec3( 0.04823, 0.01566, 0.83777 )\n\t);\n\tconst mat3 ACESOutputMat = mat3(\n\t\tvec3(  1.60475, -0.10208, -0.00327 ),\t\tvec3( -0.53108,  1.10813, -0.07276 ),\n\t\tvec3( -0.07367, -0.00605,  1.07602 )\n\t);\n\tcolor *= toneMappingExposure / 0.6;\n\tcolor = ACESInputMat * color;\n\tcolor = RRTAndODTFit( color );\n\tcolor = ACESOutputMat * color;\n\treturn saturate( color );\n}\nconst mat3 LINEAR_REC2020_TO_LINEAR_SRGB = mat3(\n\tvec3( 1.6605, - 0.1246, - 0.0182 ),\n\tvec3( - 0.5876, 1.1329, - 0.1006 ),\n\tvec3( - 0.0728, - 0.0083, 1.1187 )\n);\nconst mat3 LINEAR_SRGB_TO_LINEAR_REC2020 = mat3(\n\tvec3( 0.6274, 0.0691, 0.0164 ),\n\tvec3( 0.3293, 0.9195, 0.0880 ),\n\tvec3( 0.0433, 0.0113, 0.8956 )\n);\nvec3 agxDefaultContrastApprox( vec3 x ) {\n\tvec3 x2 = x * x;\n\tvec3 x4 = x2 * x2;\n\treturn + 15.5 * x4 * x2\n\t\t- 40.14 * x4 * x\n\t\t+ 31.96 * x4\n\t\t- 6.868 * x2 * x\n\t\t+ 0.4298 * x2\n\t\t+ 0.1191 * x\n\t\t- 0.00232;\n}\nvec3 AgXToneMapping( vec3 color ) {\n\tconst mat3 AgXInsetMatrix = mat3(\n\t\tvec3( 0.856627153315983, 0.137318972929847, 0.11189821299995 ),\n\t\tvec3( 0.0951212405381588, 0.761241990602591, 0.0767994186031903 ),\n\t\tvec3( 0.0482516061458583, 0.101439036467562, 0.811302368396859 )\n\t);\n\tconst mat3 AgXOutsetMatrix = mat3(\n\t\tvec3( 1.1271005818144368, - 0.1413297634984383, - 0.14132976349843826 ),\n\t\tvec3( - 0.11060664309660323, 1.157823702216272, - 0.11060664309660294 ),\n\t\tvec3( - 0.016493938717834573, - 0.016493938717834257, 1.2519364065950405 )\n\t);\n\tconst float AgxMinEv = - 12.47393;\tconst float AgxMaxEv = 4.026069;\n\tcolor *= toneMappingExposure;\n\tcolor = LINEAR_SRGB_TO_LINEAR_REC2020 * color;\n\tcolor = AgXInsetMatrix * color;\n\tcolor = max( color, 1e-10 );\tcolor = log2( color );\n\tcolor = ( color - AgxMinEv ) / ( AgxMaxEv - AgxMinEv );\n\tcolor = clamp( color, 0.0, 1.0 );\n\tcolor = agxDefaultContrastApprox( color );\n\tcolor = AgXOutsetMatrix * color;\n\tcolor = pow( max( vec3( 0.0 ), color ), vec3( 2.2 ) );\n\tcolor = LINEAR_REC2020_TO_LINEAR_SRGB * color;\n\tcolor = clamp( color, 0.0, 1.0 );\n\treturn color;\n}\nvec3 NeutralToneMapping( vec3 color ) {\n\tconst float StartCompression = 0.8 - 0.04;\n\tconst float Desaturation = 0.15;\n\tcolor *= toneMappingExposure;\n\tfloat x = min( color.r, min( color.g, color.b ) );\n\tfloat offset = x < 0.08 ? x - 6.25 * x * x : 0.04;\n\tcolor -= offset;\n\tfloat peak = max( color.r, max( color.g, color.b ) );\n\tif ( peak < StartCompression ) return color;\n\tfloat d = 1. - StartCompression;\n\tfloat newPeak = 1. - d * d / ( peak + d - StartCompression );\n\tcolor *= newPeak / peak;\n\tfloat g = 1. - 1. / ( Desaturation * ( peak - newPeak ) + 1. );\n\treturn mix( color, vec3( newPeak ), g );\n}\nvec3 CustomToneMapping( vec3 color ) { return color; }";
var $3dd44ec8564e7230$var$transmission_fragment = "#ifdef USE_TRANSMISSION\n\tmaterial.transmission = transmission;\n\tmaterial.transmissionAlpha = 1.0;\n\tmaterial.thickness = thickness;\n\tmaterial.attenuationDistance = attenuationDistance;\n\tmaterial.attenuationColor = attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tmaterial.transmission *= texture2D( transmissionMap, vTransmissionMapUv ).r;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tmaterial.thickness *= texture2D( thicknessMap, vThicknessMapUv ).g;\n\t#endif\n\tvec3 pos = vWorldPosition;\n\tvec3 v = normalize( cameraPosition - pos );\n\tvec3 n = inverseTransformDirection( normal, viewMatrix );\n\tvec4 transmitted = getIBLVolumeRefraction(\n\t\tn, v, material.roughness, material.diffuseColor, material.specularColor, material.specularF90,\n\t\tpos, modelMatrix, viewMatrix, projectionMatrix, material.dispersion, material.ior, material.thickness,\n\t\tmaterial.attenuationColor, material.attenuationDistance );\n\tmaterial.transmissionAlpha = mix( material.transmissionAlpha, transmitted.a, material.transmission );\n\ttotalDiffuse = mix( totalDiffuse, transmitted.rgb, material.transmission );\n#endif";
var $3dd44ec8564e7230$var$transmission_pars_fragment = "#ifdef USE_TRANSMISSION\n\tuniform float transmission;\n\tuniform float thickness;\n\tuniform float attenuationDistance;\n\tuniform vec3 attenuationColor;\n\t#ifdef USE_TRANSMISSIONMAP\n\t\tuniform sampler2D transmissionMap;\n\t#endif\n\t#ifdef USE_THICKNESSMAP\n\t\tuniform sampler2D thicknessMap;\n\t#endif\n\tuniform vec2 transmissionSamplerSize;\n\tuniform sampler2D transmissionSamplerMap;\n\tuniform mat4 modelMatrix;\n\tuniform mat4 projectionMatrix;\n\tvarying vec3 vWorldPosition;\n\tfloat w0( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - a + 3.0 ) - 3.0 ) + 1.0 );\n\t}\n\tfloat w1( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a *  a * ( 3.0 * a - 6.0 ) + 4.0 );\n\t}\n\tfloat w2( float a ){\n\t\treturn ( 1.0 / 6.0 ) * ( a * ( a * ( - 3.0 * a + 3.0 ) + 3.0 ) + 1.0 );\n\t}\n\tfloat w3( float a ) {\n\t\treturn ( 1.0 / 6.0 ) * ( a * a * a );\n\t}\n\tfloat g0( float a ) {\n\t\treturn w0( a ) + w1( a );\n\t}\n\tfloat g1( float a ) {\n\t\treturn w2( a ) + w3( a );\n\t}\n\tfloat h0( float a ) {\n\t\treturn - 1.0 + w1( a ) / ( w0( a ) + w1( a ) );\n\t}\n\tfloat h1( float a ) {\n\t\treturn 1.0 + w3( a ) / ( w2( a ) + w3( a ) );\n\t}\n\tvec4 bicubic( sampler2D tex, vec2 uv, vec4 texelSize, float lod ) {\n\t\tuv = uv * texelSize.zw + 0.5;\n\t\tvec2 iuv = floor( uv );\n\t\tvec2 fuv = fract( uv );\n\t\tfloat g0x = g0( fuv.x );\n\t\tfloat g1x = g1( fuv.x );\n\t\tfloat h0x = h0( fuv.x );\n\t\tfloat h1x = h1( fuv.x );\n\t\tfloat h0y = h0( fuv.y );\n\t\tfloat h1y = h1( fuv.y );\n\t\tvec2 p0 = ( vec2( iuv.x + h0x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p1 = ( vec2( iuv.x + h1x, iuv.y + h0y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p2 = ( vec2( iuv.x + h0x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\tvec2 p3 = ( vec2( iuv.x + h1x, iuv.y + h1y ) - 0.5 ) * texelSize.xy;\n\t\treturn g0( fuv.y ) * ( g0x * textureLod( tex, p0, lod ) + g1x * textureLod( tex, p1, lod ) ) +\n\t\t\tg1( fuv.y ) * ( g0x * textureLod( tex, p2, lod ) + g1x * textureLod( tex, p3, lod ) );\n\t}\n\tvec4 textureBicubic( sampler2D sampler, vec2 uv, float lod ) {\n\t\tvec2 fLodSize = vec2( textureSize( sampler, int( lod ) ) );\n\t\tvec2 cLodSize = vec2( textureSize( sampler, int( lod + 1.0 ) ) );\n\t\tvec2 fLodSizeInv = 1.0 / fLodSize;\n\t\tvec2 cLodSizeInv = 1.0 / cLodSize;\n\t\tvec4 fSample = bicubic( sampler, uv, vec4( fLodSizeInv, fLodSize ), floor( lod ) );\n\t\tvec4 cSample = bicubic( sampler, uv, vec4( cLodSizeInv, cLodSize ), ceil( lod ) );\n\t\treturn mix( fSample, cSample, fract( lod ) );\n\t}\n\tvec3 getVolumeTransmissionRay( const in vec3 n, const in vec3 v, const in float thickness, const in float ior, const in mat4 modelMatrix ) {\n\t\tvec3 refractionVector = refract( - v, normalize( n ), 1.0 / ior );\n\t\tvec3 modelScale;\n\t\tmodelScale.x = length( vec3( modelMatrix[ 0 ].xyz ) );\n\t\tmodelScale.y = length( vec3( modelMatrix[ 1 ].xyz ) );\n\t\tmodelScale.z = length( vec3( modelMatrix[ 2 ].xyz ) );\n\t\treturn normalize( refractionVector ) * thickness * modelScale;\n\t}\n\tfloat applyIorToRoughness( const in float roughness, const in float ior ) {\n\t\treturn roughness * clamp( ior * 2.0 - 2.0, 0.0, 1.0 );\n\t}\n\tvec4 getTransmissionSample( const in vec2 fragCoord, const in float roughness, const in float ior ) {\n\t\tfloat lod = log2( transmissionSamplerSize.x ) * applyIorToRoughness( roughness, ior );\n\t\treturn textureBicubic( transmissionSamplerMap, fragCoord.xy, lod );\n\t}\n\tvec3 volumeAttenuation( const in float transmissionDistance, const in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tif ( isinf( attenuationDistance ) ) {\n\t\t\treturn vec3( 1.0 );\n\t\t} else {\n\t\t\tvec3 attenuationCoefficient = -log( attenuationColor ) / attenuationDistance;\n\t\t\tvec3 transmittance = exp( - attenuationCoefficient * transmissionDistance );\t\t\treturn transmittance;\n\t\t}\n\t}\n\tvec4 getIBLVolumeRefraction( const in vec3 n, const in vec3 v, const in float roughness, const in vec3 diffuseColor,\n\t\tconst in vec3 specularColor, const in float specularF90, const in vec3 position, const in mat4 modelMatrix,\n\t\tconst in mat4 viewMatrix, const in mat4 projMatrix, const in float dispersion, const in float ior, const in float thickness,\n\t\tconst in vec3 attenuationColor, const in float attenuationDistance ) {\n\t\tvec4 transmittedLight;\n\t\tvec3 transmittance;\n\t\t#ifdef USE_DISPERSION\n\t\t\tfloat halfSpread = ( ior - 1.0 ) * 0.025 * dispersion;\n\t\t\tvec3 iors = vec3( ior - halfSpread, ior, ior + halfSpread );\n\t\t\tfor ( int i = 0; i < 3; i ++ ) {\n\t\t\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, iors[ i ], modelMatrix );\n\t\t\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\t\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\t\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\t\t\trefractionCoords += 1.0;\n\t\t\t\trefractionCoords /= 2.0;\n\t\t\t\tvec4 transmissionSample = getTransmissionSample( refractionCoords, roughness, iors[ i ] );\n\t\t\t\ttransmittedLight[ i ] = transmissionSample[ i ];\n\t\t\t\ttransmittedLight.a += transmissionSample.a;\n\t\t\t\ttransmittance[ i ] = diffuseColor[ i ] * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance )[ i ];\n\t\t\t}\n\t\t\ttransmittedLight.a /= 3.0;\n\t\t#else\n\t\t\tvec3 transmissionRay = getVolumeTransmissionRay( n, v, thickness, ior, modelMatrix );\n\t\t\tvec3 refractedRayExit = position + transmissionRay;\n\t\t\tvec4 ndcPos = projMatrix * viewMatrix * vec4( refractedRayExit, 1.0 );\n\t\t\tvec2 refractionCoords = ndcPos.xy / ndcPos.w;\n\t\t\trefractionCoords += 1.0;\n\t\t\trefractionCoords /= 2.0;\n\t\t\ttransmittedLight = getTransmissionSample( refractionCoords, roughness, ior );\n\t\t\ttransmittance = diffuseColor * volumeAttenuation( length( transmissionRay ), attenuationColor, attenuationDistance );\n\t\t#endif\n\t\tvec3 attenuatedColor = transmittance * transmittedLight.rgb;\n\t\tvec3 F = EnvironmentBRDF( n, v, specularColor, specularF90, roughness );\n\t\tfloat transmittanceFactor = ( transmittance.r + transmittance.g + transmittance.b ) / 3.0;\n\t\treturn vec4( ( 1.0 - F ) * attenuatedColor, 1.0 - ( 1.0 - transmittedLight.a ) * transmittanceFactor );\n\t}\n#endif";
var $3dd44ec8564e7230$var$uv_pars_fragment = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif";
var $3dd44ec8564e7230$var$uv_pars_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvarying vec2 vUv;\n#endif\n#ifdef USE_MAP\n\tuniform mat3 mapTransform;\n\tvarying vec2 vMapUv;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform mat3 alphaMapTransform;\n\tvarying vec2 vAlphaMapUv;\n#endif\n#ifdef USE_LIGHTMAP\n\tuniform mat3 lightMapTransform;\n\tvarying vec2 vLightMapUv;\n#endif\n#ifdef USE_AOMAP\n\tuniform mat3 aoMapTransform;\n\tvarying vec2 vAoMapUv;\n#endif\n#ifdef USE_BUMPMAP\n\tuniform mat3 bumpMapTransform;\n\tvarying vec2 vBumpMapUv;\n#endif\n#ifdef USE_NORMALMAP\n\tuniform mat3 normalMapTransform;\n\tvarying vec2 vNormalMapUv;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tuniform mat3 displacementMapTransform;\n\tvarying vec2 vDisplacementMapUv;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tuniform mat3 emissiveMapTransform;\n\tvarying vec2 vEmissiveMapUv;\n#endif\n#ifdef USE_METALNESSMAP\n\tuniform mat3 metalnessMapTransform;\n\tvarying vec2 vMetalnessMapUv;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tuniform mat3 roughnessMapTransform;\n\tvarying vec2 vRoughnessMapUv;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tuniform mat3 anisotropyMapTransform;\n\tvarying vec2 vAnisotropyMapUv;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tuniform mat3 clearcoatMapTransform;\n\tvarying vec2 vClearcoatMapUv;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform mat3 clearcoatNormalMapTransform;\n\tvarying vec2 vClearcoatNormalMapUv;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform mat3 clearcoatRoughnessMapTransform;\n\tvarying vec2 vClearcoatRoughnessMapUv;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tuniform mat3 sheenColorMapTransform;\n\tvarying vec2 vSheenColorMapUv;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tuniform mat3 sheenRoughnessMapTransform;\n\tvarying vec2 vSheenRoughnessMapUv;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tuniform mat3 iridescenceMapTransform;\n\tvarying vec2 vIridescenceMapUv;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tuniform mat3 iridescenceThicknessMapTransform;\n\tvarying vec2 vIridescenceThicknessMapUv;\n#endif\n#ifdef USE_SPECULARMAP\n\tuniform mat3 specularMapTransform;\n\tvarying vec2 vSpecularMapUv;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tuniform mat3 specularColorMapTransform;\n\tvarying vec2 vSpecularColorMapUv;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tuniform mat3 specularIntensityMapTransform;\n\tvarying vec2 vSpecularIntensityMapUv;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tuniform mat3 transmissionMapTransform;\n\tvarying vec2 vTransmissionMapUv;\n#endif\n#ifdef USE_THICKNESSMAP\n\tuniform mat3 thicknessMapTransform;\n\tvarying vec2 vThicknessMapUv;\n#endif";
var $3dd44ec8564e7230$var$uv_vertex = "#if defined( USE_UV ) || defined( USE_ANISOTROPY )\n\tvUv = vec3( uv, 1 ).xy;\n#endif\n#ifdef USE_MAP\n\tvMapUv = ( mapTransform * vec3( MAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ALPHAMAP\n\tvAlphaMapUv = ( alphaMapTransform * vec3( ALPHAMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_LIGHTMAP\n\tvLightMapUv = ( lightMapTransform * vec3( LIGHTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_AOMAP\n\tvAoMapUv = ( aoMapTransform * vec3( AOMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_BUMPMAP\n\tvBumpMapUv = ( bumpMapTransform * vec3( BUMPMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_NORMALMAP\n\tvNormalMapUv = ( normalMapTransform * vec3( NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_DISPLACEMENTMAP\n\tvDisplacementMapUv = ( displacementMapTransform * vec3( DISPLACEMENTMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_EMISSIVEMAP\n\tvEmissiveMapUv = ( emissiveMapTransform * vec3( EMISSIVEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_METALNESSMAP\n\tvMetalnessMapUv = ( metalnessMapTransform * vec3( METALNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ROUGHNESSMAP\n\tvRoughnessMapUv = ( roughnessMapTransform * vec3( ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_ANISOTROPYMAP\n\tvAnisotropyMapUv = ( anisotropyMapTransform * vec3( ANISOTROPYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOATMAP\n\tvClearcoatMapUv = ( clearcoatMapTransform * vec3( CLEARCOATMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tvClearcoatNormalMapUv = ( clearcoatNormalMapTransform * vec3( CLEARCOAT_NORMALMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tvClearcoatRoughnessMapUv = ( clearcoatRoughnessMapTransform * vec3( CLEARCOAT_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCEMAP\n\tvIridescenceMapUv = ( iridescenceMapTransform * vec3( IRIDESCENCEMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_IRIDESCENCE_THICKNESSMAP\n\tvIridescenceThicknessMapUv = ( iridescenceThicknessMapTransform * vec3( IRIDESCENCE_THICKNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_COLORMAP\n\tvSheenColorMapUv = ( sheenColorMapTransform * vec3( SHEEN_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SHEEN_ROUGHNESSMAP\n\tvSheenRoughnessMapUv = ( sheenRoughnessMapTransform * vec3( SHEEN_ROUGHNESSMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULARMAP\n\tvSpecularMapUv = ( specularMapTransform * vec3( SPECULARMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_COLORMAP\n\tvSpecularColorMapUv = ( specularColorMapTransform * vec3( SPECULAR_COLORMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_SPECULAR_INTENSITYMAP\n\tvSpecularIntensityMapUv = ( specularIntensityMapTransform * vec3( SPECULAR_INTENSITYMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_TRANSMISSIONMAP\n\tvTransmissionMapUv = ( transmissionMapTransform * vec3( TRANSMISSIONMAP_UV, 1 ) ).xy;\n#endif\n#ifdef USE_THICKNESSMAP\n\tvThicknessMapUv = ( thicknessMapTransform * vec3( THICKNESSMAP_UV, 1 ) ).xy;\n#endif";
var $3dd44ec8564e7230$var$worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP ) || defined ( USE_TRANSMISSION ) || NUM_SPOT_LIGHT_COORDS > 0\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_BATCHING\n\t\tworldPosition = batchingMatrix * worldPosition;\n\t#endif\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif";
const $3dd44ec8564e7230$var$vertex$h = "varying vec2 vUv;\nuniform mat3 uvTransform;\nvoid main() {\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\tgl_Position = vec4( position.xy, 1.0, 1.0 );\n}";
const $3dd44ec8564e7230$var$fragment$h = "uniform sampler2D t2D;\nuniform float backgroundIntensity;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\t#ifdef DECODE_VIDEO_TEXTURE\n\t\ttexColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$g = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";
const $3dd44ec8564e7230$var$fragment$g = "#ifdef ENVMAP_TYPE_CUBE\n\tuniform samplerCube envMap;\n#elif defined( ENVMAP_TYPE_CUBE_UV )\n\tuniform sampler2D envMap;\n#endif\nuniform float flipEnvMap;\nuniform float backgroundBlurriness;\nuniform float backgroundIntensity;\nuniform mat3 backgroundRotation;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 texColor = textureCube( envMap, backgroundRotation * vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );\n\t#else\n\t\tvec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t#endif\n\ttexColor.rgb *= backgroundIntensity;\n\tgl_FragColor = texColor;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$f = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\tgl_Position.z = gl_Position.w;\n}";
const $3dd44ec8564e7230$var$fragment$f = "uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldDirection;\nvoid main() {\n\tvec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );\n\tgl_FragColor = texColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$e = "#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <skinbase_vertex>\n\t#include <morphinstance_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvHighPrecisionZW = gl_Position.zw;\n}";
const $3dd44ec8564e7230$var$fragment$e = "#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <clipping_planes_fragment>\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <logdepthbuf_fragment>\n\tfloat fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( fragCoordZ );\n\t#elif DEPTH_PACKING == 3202\n\t\tgl_FragColor = vec4( packDepthToRGB( fragCoordZ ), 1.0 );\n\t#elif DEPTH_PACKING == 3203\n\t\tgl_FragColor = vec4( packDepthToRG( fragCoordZ ), 0.0, 1.0 );\n\t#endif\n}";
const $3dd44ec8564e7230$var$vertex$d = "#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <skinbase_vertex>\n\t#include <morphinstance_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition.xyz;\n}";
const $3dd44ec8564e7230$var$fragment$d = "#define DISTANCE\nuniform vec3 referencePosition;\nuniform float nearDistance;\nuniform float farDistance;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <clipping_planes_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}";
const $3dd44ec8564e7230$var$vertex$c = "varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$c = "uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$b = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$b = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$a = "#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$a = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel = texture2D( lightMap, vLightMapUv );\n\t\treflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$9 = "#define LAMBERT\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$9 = "#define LAMBERT\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_lambert_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_lambert_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$8 = "#define MATCAP\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}";
const $3dd44ec8564e7230$var$fragment$8 = "#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\n#include <common>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tvec3 viewDir = normalize( vViewPosition );\n\tvec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );\n\tvec3 y = cross( viewDir, x );\n\tvec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5;\n\t#ifdef USE_MATCAP\n\t\tvec4 matcapColor = texture2D( matcap, uv );\n\t#else\n\t\tvec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$7 = "#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}";
const $3dd44ec8564e7230$var$fragment$7 = "#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )\n\tvarying vec3 vViewPosition;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <normal_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( 0.0, 0.0, 0.0, opacity );\n\t#include <clipping_planes_fragment>\n\t#include <logdepthbuf_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), diffuseColor.a );\n\t#ifdef OPAQUE\n\t\tgl_FragColor.a = 1.0;\n\t#endif\n}";
const $3dd44ec8564e7230$var$vertex$6 = "#define PHONG\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$6 = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$5 = "#define STANDARD\nvarying vec3 vViewPosition;\n#ifdef USE_TRANSMISSION\n\tvarying vec3 vWorldPosition;\n#endif\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n#ifdef USE_TRANSMISSION\n\tvWorldPosition = worldPosition.xyz;\n#endif\n}";
const $3dd44ec8564e7230$var$fragment$5 = "#define STANDARD\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef IOR\n\tuniform float ior;\n#endif\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n#endif\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_DISPERSION\n\tuniform float dispersion;\n#endif\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\n#ifdef USE_ANISOTROPY\n\tuniform vec2 anisotropyVector;\n\t#ifdef USE_ANISOTROPYMAP\n\t\tuniform sampler2D anisotropyMap;\n\t#endif\n#endif\nvarying vec3 vViewPosition;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <iridescence_fragment>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <iridescence_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\t#include <transmission_fragment>\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\t#ifdef USE_SHEEN\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;\n\t#endif\n\t#ifdef USE_CLEARCOAT\n\t\tfloat dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );\n\t\tvec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );\n\t\toutgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;\n\t#endif\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$4 = "#define TOON\nvarying vec3 vViewPosition;\n#include <common>\n#include <batching_pars_vertex>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$4 = "#define TOON\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_toon_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\t#include <lights_toon_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$3 = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n#ifdef USE_POINTS_UV\n\tvarying vec2 vUv;\n\tuniform mat3 uvTransform;\n#endif\nvoid main() {\n\t#ifdef USE_POINTS_UV\n\t\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n\t#endif\n\t#include <color_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphcolor_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <project_vertex>\n\tgl_PointSize = size;\n\t#ifdef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$3 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$2 = "#include <common>\n#include <batching_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <batching_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphinstance_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$2 = "uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <logdepthbuf_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\t#include <logdepthbuf_fragment>\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
const $3dd44ec8564e7230$var$vertex$1 = "uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix[ 3 ];\n\tvec2 scale = vec2( length( modelMatrix[ 0 ].xyz ), length( modelMatrix[ 1 ].xyz ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
const $3dd44ec8564e7230$var$fragment$1 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
const $3dd44ec8564e7230$export$955f9f2e84c43c8b = {
    alphahash_fragment: $3dd44ec8564e7230$var$alphahash_fragment,
    alphahash_pars_fragment: $3dd44ec8564e7230$var$alphahash_pars_fragment,
    alphamap_fragment: $3dd44ec8564e7230$var$alphamap_fragment,
    alphamap_pars_fragment: $3dd44ec8564e7230$var$alphamap_pars_fragment,
    alphatest_fragment: $3dd44ec8564e7230$var$alphatest_fragment,
    alphatest_pars_fragment: $3dd44ec8564e7230$var$alphatest_pars_fragment,
    aomap_fragment: $3dd44ec8564e7230$var$aomap_fragment,
    aomap_pars_fragment: $3dd44ec8564e7230$var$aomap_pars_fragment,
    batching_pars_vertex: $3dd44ec8564e7230$var$batching_pars_vertex,
    batching_vertex: $3dd44ec8564e7230$var$batching_vertex,
    begin_vertex: $3dd44ec8564e7230$var$begin_vertex,
    beginnormal_vertex: $3dd44ec8564e7230$var$beginnormal_vertex,
    bsdfs: $3dd44ec8564e7230$var$bsdfs,
    iridescence_fragment: $3dd44ec8564e7230$var$iridescence_fragment,
    bumpmap_pars_fragment: $3dd44ec8564e7230$var$bumpmap_pars_fragment,
    clipping_planes_fragment: $3dd44ec8564e7230$var$clipping_planes_fragment,
    clipping_planes_pars_fragment: $3dd44ec8564e7230$var$clipping_planes_pars_fragment,
    clipping_planes_pars_vertex: $3dd44ec8564e7230$var$clipping_planes_pars_vertex,
    clipping_planes_vertex: $3dd44ec8564e7230$var$clipping_planes_vertex,
    color_fragment: $3dd44ec8564e7230$var$color_fragment,
    color_pars_fragment: $3dd44ec8564e7230$var$color_pars_fragment,
    color_pars_vertex: $3dd44ec8564e7230$var$color_pars_vertex,
    color_vertex: $3dd44ec8564e7230$var$color_vertex,
    common: $3dd44ec8564e7230$var$common,
    cube_uv_reflection_fragment: $3dd44ec8564e7230$var$cube_uv_reflection_fragment,
    defaultnormal_vertex: $3dd44ec8564e7230$var$defaultnormal_vertex,
    displacementmap_pars_vertex: $3dd44ec8564e7230$var$displacementmap_pars_vertex,
    displacementmap_vertex: $3dd44ec8564e7230$var$displacementmap_vertex,
    emissivemap_fragment: $3dd44ec8564e7230$var$emissivemap_fragment,
    emissivemap_pars_fragment: $3dd44ec8564e7230$var$emissivemap_pars_fragment,
    colorspace_fragment: $3dd44ec8564e7230$var$colorspace_fragment,
    colorspace_pars_fragment: $3dd44ec8564e7230$var$colorspace_pars_fragment,
    envmap_fragment: $3dd44ec8564e7230$var$envmap_fragment,
    envmap_common_pars_fragment: $3dd44ec8564e7230$var$envmap_common_pars_fragment,
    envmap_pars_fragment: $3dd44ec8564e7230$var$envmap_pars_fragment,
    envmap_pars_vertex: $3dd44ec8564e7230$var$envmap_pars_vertex,
    envmap_physical_pars_fragment: $3dd44ec8564e7230$var$envmap_physical_pars_fragment,
    envmap_vertex: $3dd44ec8564e7230$var$envmap_vertex,
    fog_vertex: $3dd44ec8564e7230$var$fog_vertex,
    fog_pars_vertex: $3dd44ec8564e7230$var$fog_pars_vertex,
    fog_fragment: $3dd44ec8564e7230$var$fog_fragment,
    fog_pars_fragment: $3dd44ec8564e7230$var$fog_pars_fragment,
    gradientmap_pars_fragment: $3dd44ec8564e7230$var$gradientmap_pars_fragment,
    lightmap_pars_fragment: $3dd44ec8564e7230$var$lightmap_pars_fragment,
    lights_lambert_fragment: $3dd44ec8564e7230$var$lights_lambert_fragment,
    lights_lambert_pars_fragment: $3dd44ec8564e7230$var$lights_lambert_pars_fragment,
    lights_pars_begin: $3dd44ec8564e7230$var$lights_pars_begin,
    lights_toon_fragment: $3dd44ec8564e7230$var$lights_toon_fragment,
    lights_toon_pars_fragment: $3dd44ec8564e7230$var$lights_toon_pars_fragment,
    lights_phong_fragment: $3dd44ec8564e7230$var$lights_phong_fragment,
    lights_phong_pars_fragment: $3dd44ec8564e7230$var$lights_phong_pars_fragment,
    lights_physical_fragment: $3dd44ec8564e7230$var$lights_physical_fragment,
    lights_physical_pars_fragment: $3dd44ec8564e7230$var$lights_physical_pars_fragment,
    lights_fragment_begin: $3dd44ec8564e7230$var$lights_fragment_begin,
    lights_fragment_maps: $3dd44ec8564e7230$var$lights_fragment_maps,
    lights_fragment_end: $3dd44ec8564e7230$var$lights_fragment_end,
    logdepthbuf_fragment: $3dd44ec8564e7230$var$logdepthbuf_fragment,
    logdepthbuf_pars_fragment: $3dd44ec8564e7230$var$logdepthbuf_pars_fragment,
    logdepthbuf_pars_vertex: $3dd44ec8564e7230$var$logdepthbuf_pars_vertex,
    logdepthbuf_vertex: $3dd44ec8564e7230$var$logdepthbuf_vertex,
    map_fragment: $3dd44ec8564e7230$var$map_fragment,
    map_pars_fragment: $3dd44ec8564e7230$var$map_pars_fragment,
    map_particle_fragment: $3dd44ec8564e7230$var$map_particle_fragment,
    map_particle_pars_fragment: $3dd44ec8564e7230$var$map_particle_pars_fragment,
    metalnessmap_fragment: $3dd44ec8564e7230$var$metalnessmap_fragment,
    metalnessmap_pars_fragment: $3dd44ec8564e7230$var$metalnessmap_pars_fragment,
    morphinstance_vertex: $3dd44ec8564e7230$var$morphinstance_vertex,
    morphcolor_vertex: $3dd44ec8564e7230$var$morphcolor_vertex,
    morphnormal_vertex: $3dd44ec8564e7230$var$morphnormal_vertex,
    morphtarget_pars_vertex: $3dd44ec8564e7230$var$morphtarget_pars_vertex,
    morphtarget_vertex: $3dd44ec8564e7230$var$morphtarget_vertex,
    normal_fragment_begin: $3dd44ec8564e7230$var$normal_fragment_begin,
    normal_fragment_maps: $3dd44ec8564e7230$var$normal_fragment_maps,
    normal_pars_fragment: $3dd44ec8564e7230$var$normal_pars_fragment,
    normal_pars_vertex: $3dd44ec8564e7230$var$normal_pars_vertex,
    normal_vertex: $3dd44ec8564e7230$var$normal_vertex,
    normalmap_pars_fragment: $3dd44ec8564e7230$var$normalmap_pars_fragment,
    clearcoat_normal_fragment_begin: $3dd44ec8564e7230$var$clearcoat_normal_fragment_begin,
    clearcoat_normal_fragment_maps: $3dd44ec8564e7230$var$clearcoat_normal_fragment_maps,
    clearcoat_pars_fragment: $3dd44ec8564e7230$var$clearcoat_pars_fragment,
    iridescence_pars_fragment: $3dd44ec8564e7230$var$iridescence_pars_fragment,
    opaque_fragment: $3dd44ec8564e7230$var$opaque_fragment,
    packing: $3dd44ec8564e7230$var$packing,
    premultiplied_alpha_fragment: $3dd44ec8564e7230$var$premultiplied_alpha_fragment,
    project_vertex: $3dd44ec8564e7230$var$project_vertex,
    dithering_fragment: $3dd44ec8564e7230$var$dithering_fragment,
    dithering_pars_fragment: $3dd44ec8564e7230$var$dithering_pars_fragment,
    roughnessmap_fragment: $3dd44ec8564e7230$var$roughnessmap_fragment,
    roughnessmap_pars_fragment: $3dd44ec8564e7230$var$roughnessmap_pars_fragment,
    shadowmap_pars_fragment: $3dd44ec8564e7230$var$shadowmap_pars_fragment,
    shadowmap_pars_vertex: $3dd44ec8564e7230$var$shadowmap_pars_vertex,
    shadowmap_vertex: $3dd44ec8564e7230$var$shadowmap_vertex,
    shadowmask_pars_fragment: $3dd44ec8564e7230$var$shadowmask_pars_fragment,
    skinbase_vertex: $3dd44ec8564e7230$var$skinbase_vertex,
    skinning_pars_vertex: $3dd44ec8564e7230$var$skinning_pars_vertex,
    skinning_vertex: $3dd44ec8564e7230$var$skinning_vertex,
    skinnormal_vertex: $3dd44ec8564e7230$var$skinnormal_vertex,
    specularmap_fragment: $3dd44ec8564e7230$var$specularmap_fragment,
    specularmap_pars_fragment: $3dd44ec8564e7230$var$specularmap_pars_fragment,
    tonemapping_fragment: $3dd44ec8564e7230$var$tonemapping_fragment,
    tonemapping_pars_fragment: $3dd44ec8564e7230$var$tonemapping_pars_fragment,
    transmission_fragment: $3dd44ec8564e7230$var$transmission_fragment,
    transmission_pars_fragment: $3dd44ec8564e7230$var$transmission_pars_fragment,
    uv_pars_fragment: $3dd44ec8564e7230$var$uv_pars_fragment,
    uv_pars_vertex: $3dd44ec8564e7230$var$uv_pars_vertex,
    uv_vertex: $3dd44ec8564e7230$var$uv_vertex,
    worldpos_vertex: $3dd44ec8564e7230$var$worldpos_vertex,
    background_vert: $3dd44ec8564e7230$var$vertex$h,
    background_frag: $3dd44ec8564e7230$var$fragment$h,
    backgroundCube_vert: $3dd44ec8564e7230$var$vertex$g,
    backgroundCube_frag: $3dd44ec8564e7230$var$fragment$g,
    cube_vert: $3dd44ec8564e7230$var$vertex$f,
    cube_frag: $3dd44ec8564e7230$var$fragment$f,
    depth_vert: $3dd44ec8564e7230$var$vertex$e,
    depth_frag: $3dd44ec8564e7230$var$fragment$e,
    distanceRGBA_vert: $3dd44ec8564e7230$var$vertex$d,
    distanceRGBA_frag: $3dd44ec8564e7230$var$fragment$d,
    equirect_vert: $3dd44ec8564e7230$var$vertex$c,
    equirect_frag: $3dd44ec8564e7230$var$fragment$c,
    linedashed_vert: $3dd44ec8564e7230$var$vertex$b,
    linedashed_frag: $3dd44ec8564e7230$var$fragment$b,
    meshbasic_vert: $3dd44ec8564e7230$var$vertex$a,
    meshbasic_frag: $3dd44ec8564e7230$var$fragment$a,
    meshlambert_vert: $3dd44ec8564e7230$var$vertex$9,
    meshlambert_frag: $3dd44ec8564e7230$var$fragment$9,
    meshmatcap_vert: $3dd44ec8564e7230$var$vertex$8,
    meshmatcap_frag: $3dd44ec8564e7230$var$fragment$8,
    meshnormal_vert: $3dd44ec8564e7230$var$vertex$7,
    meshnormal_frag: $3dd44ec8564e7230$var$fragment$7,
    meshphong_vert: $3dd44ec8564e7230$var$vertex$6,
    meshphong_frag: $3dd44ec8564e7230$var$fragment$6,
    meshphysical_vert: $3dd44ec8564e7230$var$vertex$5,
    meshphysical_frag: $3dd44ec8564e7230$var$fragment$5,
    meshtoon_vert: $3dd44ec8564e7230$var$vertex$4,
    meshtoon_frag: $3dd44ec8564e7230$var$fragment$4,
    points_vert: $3dd44ec8564e7230$var$vertex$3,
    points_frag: $3dd44ec8564e7230$var$fragment$3,
    shadow_vert: $3dd44ec8564e7230$var$vertex$2,
    shadow_frag: $3dd44ec8564e7230$var$fragment$2,
    sprite_vert: $3dd44ec8564e7230$var$vertex$1,
    sprite_frag: $3dd44ec8564e7230$var$fragment$1
};
/**
 * Uniforms library for shared webgl shaders
 */ const $3dd44ec8564e7230$export$6643083551874bf5 = {
    common: {
        diffuse: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0xffffff)
        },
        opacity: {
            value: 1.0
        },
        map: {
            value: null
        },
        mapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        alphaMap: {
            value: null
        },
        alphaMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        alphaTest: {
            value: 0
        }
    },
    specularmap: {
        specularMap: {
            value: null
        },
        specularMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    envmap: {
        envMap: {
            value: null
        },
        envMapRotation: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        flipEnvMap: {
            value: -1
        },
        reflectivity: {
            value: 1.0
        },
        ior: {
            value: 1.5
        },
        refractionRatio: {
            value: 0.98
        }
    },
    aomap: {
        aoMap: {
            value: null
        },
        aoMapIntensity: {
            value: 1
        },
        aoMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    lightmap: {
        lightMap: {
            value: null
        },
        lightMapIntensity: {
            value: 1
        },
        lightMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    bumpmap: {
        bumpMap: {
            value: null
        },
        bumpMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        bumpScale: {
            value: 1
        }
    },
    normalmap: {
        normalMap: {
            value: null
        },
        normalMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        normalScale: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(1, 1)
        }
    },
    displacementmap: {
        displacementMap: {
            value: null
        },
        displacementMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        displacementScale: {
            value: 1
        },
        displacementBias: {
            value: 0
        }
    },
    emissivemap: {
        emissiveMap: {
            value: null
        },
        emissiveMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    metalnessmap: {
        metalnessMap: {
            value: null
        },
        metalnessMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    roughnessmap: {
        roughnessMap: {
            value: null
        },
        roughnessMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    gradientmap: {
        gradientMap: {
            value: null
        }
    },
    fog: {
        fogDensity: {
            value: 0.00025
        },
        fogNear: {
            value: 1
        },
        fogFar: {
            value: 2000
        },
        fogColor: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0xffffff)
        }
    },
    lights: {
        ambientLightColor: {
            value: []
        },
        lightProbe: {
            value: []
        },
        directionalLights: {
            value: [],
            properties: {
                direction: {},
                color: {}
            }
        },
        directionalLightShadows: {
            value: [],
            properties: {
                shadowIntensity: 1,
                shadowBias: {},
                shadowNormalBias: {},
                shadowRadius: {},
                shadowMapSize: {}
            }
        },
        directionalShadowMap: {
            value: []
        },
        directionalShadowMatrix: {
            value: []
        },
        spotLights: {
            value: [],
            properties: {
                color: {},
                position: {},
                direction: {},
                distance: {},
                coneCos: {},
                penumbraCos: {},
                decay: {}
            }
        },
        spotLightShadows: {
            value: [],
            properties: {
                shadowIntensity: 1,
                shadowBias: {},
                shadowNormalBias: {},
                shadowRadius: {},
                shadowMapSize: {}
            }
        },
        spotLightMap: {
            value: []
        },
        spotShadowMap: {
            value: []
        },
        spotLightMatrix: {
            value: []
        },
        pointLights: {
            value: [],
            properties: {
                color: {},
                position: {},
                decay: {},
                distance: {}
            }
        },
        pointLightShadows: {
            value: [],
            properties: {
                shadowIntensity: 1,
                shadowBias: {},
                shadowNormalBias: {},
                shadowRadius: {},
                shadowMapSize: {},
                shadowCameraNear: {},
                shadowCameraFar: {}
            }
        },
        pointShadowMap: {
            value: []
        },
        pointShadowMatrix: {
            value: []
        },
        hemisphereLights: {
            value: [],
            properties: {
                direction: {},
                skyColor: {},
                groundColor: {}
            }
        },
        // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
        rectAreaLights: {
            value: [],
            properties: {
                color: {},
                position: {},
                width: {},
                height: {}
            }
        },
        ltc_1: {
            value: null
        },
        ltc_2: {
            value: null
        }
    },
    points: {
        diffuse: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0xffffff)
        },
        opacity: {
            value: 1.0
        },
        size: {
            value: 1.0
        },
        scale: {
            value: 1.0
        },
        map: {
            value: null
        },
        alphaMap: {
            value: null
        },
        alphaMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        alphaTest: {
            value: 0
        },
        uvTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        }
    },
    sprite: {
        diffuse: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0xffffff)
        },
        opacity: {
            value: 1.0
        },
        center: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(0.5, 0.5)
        },
        rotation: {
            value: 0.0
        },
        map: {
            value: null
        },
        mapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        alphaMap: {
            value: null
        },
        alphaMapTransform: {
            value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
        },
        alphaTest: {
            value: 0
        }
    }
};
const $3dd44ec8564e7230$export$bee4a7d47f8f5014 = {
    basic: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.specularmap,
            $3dd44ec8564e7230$export$6643083551874bf5.envmap,
            $3dd44ec8564e7230$export$6643083551874bf5.aomap,
            $3dd44ec8564e7230$export$6643083551874bf5.lightmap,
            $3dd44ec8564e7230$export$6643083551874bf5.fog
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshbasic_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshbasic_frag
    },
    lambert: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.specularmap,
            $3dd44ec8564e7230$export$6643083551874bf5.envmap,
            $3dd44ec8564e7230$export$6643083551874bf5.aomap,
            $3dd44ec8564e7230$export$6643083551874bf5.lightmap,
            $3dd44ec8564e7230$export$6643083551874bf5.emissivemap,
            $3dd44ec8564e7230$export$6643083551874bf5.bumpmap,
            $3dd44ec8564e7230$export$6643083551874bf5.normalmap,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            $3dd44ec8564e7230$export$6643083551874bf5.lights,
            {
                emissive: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000)
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshlambert_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshlambert_frag
    },
    phong: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.specularmap,
            $3dd44ec8564e7230$export$6643083551874bf5.envmap,
            $3dd44ec8564e7230$export$6643083551874bf5.aomap,
            $3dd44ec8564e7230$export$6643083551874bf5.lightmap,
            $3dd44ec8564e7230$export$6643083551874bf5.emissivemap,
            $3dd44ec8564e7230$export$6643083551874bf5.bumpmap,
            $3dd44ec8564e7230$export$6643083551874bf5.normalmap,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            $3dd44ec8564e7230$export$6643083551874bf5.lights,
            {
                emissive: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000)
                },
                specular: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x111111)
                },
                shininess: {
                    value: 30
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshphong_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshphong_frag
    },
    standard: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.envmap,
            $3dd44ec8564e7230$export$6643083551874bf5.aomap,
            $3dd44ec8564e7230$export$6643083551874bf5.lightmap,
            $3dd44ec8564e7230$export$6643083551874bf5.emissivemap,
            $3dd44ec8564e7230$export$6643083551874bf5.bumpmap,
            $3dd44ec8564e7230$export$6643083551874bf5.normalmap,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            $3dd44ec8564e7230$export$6643083551874bf5.roughnessmap,
            $3dd44ec8564e7230$export$6643083551874bf5.metalnessmap,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            $3dd44ec8564e7230$export$6643083551874bf5.lights,
            {
                emissive: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000)
                },
                roughness: {
                    value: 1.0
                },
                metalness: {
                    value: 0.0
                },
                envMapIntensity: {
                    value: 1
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshphysical_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshphysical_frag
    },
    toon: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.aomap,
            $3dd44ec8564e7230$export$6643083551874bf5.lightmap,
            $3dd44ec8564e7230$export$6643083551874bf5.emissivemap,
            $3dd44ec8564e7230$export$6643083551874bf5.bumpmap,
            $3dd44ec8564e7230$export$6643083551874bf5.normalmap,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            $3dd44ec8564e7230$export$6643083551874bf5.gradientmap,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            $3dd44ec8564e7230$export$6643083551874bf5.lights,
            {
                emissive: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000)
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshtoon_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshtoon_frag
    },
    matcap: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.bumpmap,
            $3dd44ec8564e7230$export$6643083551874bf5.normalmap,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            {
                matcap: {
                    value: null
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshmatcap_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshmatcap_frag
    },
    points: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.points,
            $3dd44ec8564e7230$export$6643083551874bf5.fog
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.points_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.points_frag
    },
    dashed: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            {
                scale: {
                    value: 1
                },
                dashSize: {
                    value: 1
                },
                totalSize: {
                    value: 2
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.linedashed_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.linedashed_frag
    },
    depth: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.depth_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.depth_frag
    },
    normal: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.bumpmap,
            $3dd44ec8564e7230$export$6643083551874bf5.normalmap,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            {
                opacity: {
                    value: 1.0
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshnormal_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshnormal_frag
    },
    sprite: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.sprite,
            $3dd44ec8564e7230$export$6643083551874bf5.fog
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.sprite_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.sprite_frag
    },
    background: {
        uniforms: {
            uvTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            t2D: {
                value: null
            },
            backgroundIntensity: {
                value: 1
            }
        },
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.background_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.background_frag
    },
    backgroundCube: {
        uniforms: {
            envMap: {
                value: null
            },
            flipEnvMap: {
                value: -1
            },
            backgroundBlurriness: {
                value: 0
            },
            backgroundIntensity: {
                value: 1
            },
            backgroundRotation: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            }
        },
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.backgroundCube_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.backgroundCube_frag
    },
    cube: {
        uniforms: {
            tCube: {
                value: null
            },
            tFlip: {
                value: -1
            },
            opacity: {
                value: 1.0
            }
        },
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.cube_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.cube_frag
    },
    equirect: {
        uniforms: {
            tEquirect: {
                value: null
            }
        },
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.equirect_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.equirect_frag
    },
    distanceRGBA: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.common,
            $3dd44ec8564e7230$export$6643083551874bf5.displacementmap,
            {
                referencePosition: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)()
                },
                nearDistance: {
                    value: 1
                },
                farDistance: {
                    value: 1000
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.distanceRGBA_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.distanceRGBA_frag
    },
    shadow: {
        uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
            $3dd44ec8564e7230$export$6643083551874bf5.lights,
            $3dd44ec8564e7230$export$6643083551874bf5.fog,
            {
                color: {
                    value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x00000)
                },
                opacity: {
                    value: 1.0
                }
            }
        ]),
        vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.shadow_vert,
        fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.shadow_frag
    }
};
$3dd44ec8564e7230$export$bee4a7d47f8f5014.physical = {
    uniforms: /*@__PURE__*/ (0, $d5b85d29c0b78636$export$8916ce6879271f43)([
        $3dd44ec8564e7230$export$bee4a7d47f8f5014.standard.uniforms,
        {
            clearcoat: {
                value: 0
            },
            clearcoatMap: {
                value: null
            },
            clearcoatMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            clearcoatNormalMap: {
                value: null
            },
            clearcoatNormalMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            clearcoatNormalScale: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(1, 1)
            },
            clearcoatRoughness: {
                value: 0
            },
            clearcoatRoughnessMap: {
                value: null
            },
            clearcoatRoughnessMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            dispersion: {
                value: 0
            },
            iridescence: {
                value: 0
            },
            iridescenceMap: {
                value: null
            },
            iridescenceMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            iridescenceIOR: {
                value: 1.3
            },
            iridescenceThicknessMinimum: {
                value: 100
            },
            iridescenceThicknessMaximum: {
                value: 400
            },
            iridescenceThicknessMap: {
                value: null
            },
            iridescenceThicknessMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            sheen: {
                value: 0
            },
            sheenColor: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000)
            },
            sheenColorMap: {
                value: null
            },
            sheenColorMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            sheenRoughness: {
                value: 1
            },
            sheenRoughnessMap: {
                value: null
            },
            sheenRoughnessMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            transmission: {
                value: 0
            },
            transmissionMap: {
                value: null
            },
            transmissionMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            transmissionSamplerSize: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)()
            },
            transmissionSamplerMap: {
                value: null
            },
            thickness: {
                value: 0
            },
            thicknessMap: {
                value: null
            },
            thicknessMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            attenuationDistance: {
                value: 0
            },
            attenuationColor: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000)
            },
            specularColor: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(1, 1, 1)
            },
            specularColorMap: {
                value: null
            },
            specularColorMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            specularIntensity: {
                value: 1
            },
            specularIntensityMap: {
                value: null
            },
            specularIntensityMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            },
            anisotropyVector: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)()
            },
            anisotropyMap: {
                value: null
            },
            anisotropyMapTransform: {
                value: /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)()
            }
        }
    ]),
    vertexShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshphysical_vert,
    fragmentShader: $3dd44ec8564e7230$export$955f9f2e84c43c8b.meshphysical_frag
};
const $3dd44ec8564e7230$var$_rgb = {
    r: 0,
    b: 0,
    g: 0
};
const $3dd44ec8564e7230$var$_e1$1 = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$d93cc409a0768c5f)();
const $3dd44ec8564e7230$var$_m1$1 = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
function $3dd44ec8564e7230$var$WebGLBackground(renderer, cubemaps, cubeuvmaps, state, objects, alpha, premultipliedAlpha) {
    const clearColor = new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000);
    let clearAlpha = alpha === true ? 0 : 1;
    let planeMesh;
    let boxMesh;
    let currentBackground = null;
    let currentBackgroundVersion = 0;
    let currentTonemapping = null;
    function getBackground(scene) {
        let background = scene.isScene === true ? scene.background : null;
        if (background && background.isTexture) {
            const usePMREM = scene.backgroundBlurriness > 0; // use PMREM if the user wants to blur the background
            background = (usePMREM ? cubeuvmaps : cubemaps).get(background);
        }
        return background;
    }
    function render(scene) {
        let forceClear = false;
        const background = getBackground(scene);
        if (background === null) setClear(clearColor, clearAlpha);
        else if (background && background.isColor) {
            setClear(background, 1);
            forceClear = true;
        }
        const environmentBlendMode = renderer.xr.getEnvironmentBlendMode();
        if (environmentBlendMode === 'additive') state.buffers.color.setClear(0, 0, 0, 1, premultipliedAlpha);
        else if (environmentBlendMode === 'alpha-blend') state.buffers.color.setClear(0, 0, 0, 0, premultipliedAlpha);
        if (renderer.autoClear || forceClear) {
            // buffers might not be writable which is required to ensure a correct clear
            state.buffers.depth.setTest(true);
            state.buffers.depth.setMask(true);
            state.buffers.color.setMask(true);
            renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil);
        }
    }
    function addToRenderList(renderList, scene) {
        const background = getBackground(scene);
        if (background && (background.isCubeTexture || background.mapping === (0, $d5b85d29c0b78636$export$dbf3e70ff37af79))) {
            if (boxMesh === undefined) {
                boxMesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(new (0, $d5b85d29c0b78636$export$33e43285f7406bd5)(1, 1, 1), new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
                    name: 'BackgroundCubeMaterial',
                    uniforms: (0, $d5b85d29c0b78636$export$acda854380553452)($3dd44ec8564e7230$export$bee4a7d47f8f5014.backgroundCube.uniforms),
                    vertexShader: $3dd44ec8564e7230$export$bee4a7d47f8f5014.backgroundCube.vertexShader,
                    fragmentShader: $3dd44ec8564e7230$export$bee4a7d47f8f5014.backgroundCube.fragmentShader,
                    side: (0, $d5b85d29c0b78636$export$d9f0486e75b5ace),
                    depthTest: false,
                    depthWrite: false,
                    fog: false
                }));
                boxMesh.geometry.deleteAttribute('normal');
                boxMesh.geometry.deleteAttribute('uv');
                boxMesh.onBeforeRender = function(renderer, scene, camera) {
                    this.matrixWorld.copyPosition(camera.matrixWorld);
                };
                // add "envMap" material property so the renderer can evaluate it like for built-in materials
                Object.defineProperty(boxMesh.material, 'envMap', {
                    get: function() {
                        return this.uniforms.envMap.value;
                    }
                });
                objects.update(boxMesh);
            }
            $3dd44ec8564e7230$var$_e1$1.copy(scene.backgroundRotation);
            // accommodate left-handed frame
            $3dd44ec8564e7230$var$_e1$1.x *= -1;
            $3dd44ec8564e7230$var$_e1$1.y *= -1;
            $3dd44ec8564e7230$var$_e1$1.z *= -1;
            if (background.isCubeTexture && background.isRenderTargetTexture === false) {
                // environment maps which are not cube render targets or PMREMs follow a different convention
                $3dd44ec8564e7230$var$_e1$1.y *= -1;
                $3dd44ec8564e7230$var$_e1$1.z *= -1;
            }
            boxMesh.material.uniforms.envMap.value = background;
            boxMesh.material.uniforms.flipEnvMap.value = background.isCubeTexture && background.isRenderTargetTexture === false ? -1 : 1;
            boxMesh.material.uniforms.backgroundBlurriness.value = scene.backgroundBlurriness;
            boxMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;
            boxMesh.material.uniforms.backgroundRotation.value.setFromMatrix4($3dd44ec8564e7230$var$_m1$1.makeRotationFromEuler($3dd44ec8564e7230$var$_e1$1));
            boxMesh.material.toneMapped = (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(background.colorSpace) !== (0, $d5b85d29c0b78636$export$8d0a61916cc26abb);
            if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) {
                boxMesh.material.needsUpdate = true;
                currentBackground = background;
                currentBackgroundVersion = background.version;
                currentTonemapping = renderer.toneMapping;
            }
            boxMesh.layers.enableAll();
            // push to the pre-sorted opaque render list
            renderList.unshift(boxMesh, boxMesh.geometry, boxMesh.material, 0, 0, null);
        } else if (background && background.isTexture) {
            if (planeMesh === undefined) {
                planeMesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(new (0, $d5b85d29c0b78636$export$967d831af31f69ce)(2, 2), new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
                    name: 'BackgroundMaterial',
                    uniforms: (0, $d5b85d29c0b78636$export$acda854380553452)($3dd44ec8564e7230$export$bee4a7d47f8f5014.background.uniforms),
                    vertexShader: $3dd44ec8564e7230$export$bee4a7d47f8f5014.background.vertexShader,
                    fragmentShader: $3dd44ec8564e7230$export$bee4a7d47f8f5014.background.fragmentShader,
                    side: (0, $d5b85d29c0b78636$export$2ede184fc2998901),
                    depthTest: false,
                    depthWrite: false,
                    fog: false
                }));
                planeMesh.geometry.deleteAttribute('normal');
                // add "map" material property so the renderer can evaluate it like for built-in materials
                Object.defineProperty(planeMesh.material, 'map', {
                    get: function() {
                        return this.uniforms.t2D.value;
                    }
                });
                objects.update(planeMesh);
            }
            planeMesh.material.uniforms.t2D.value = background;
            planeMesh.material.uniforms.backgroundIntensity.value = scene.backgroundIntensity;
            planeMesh.material.toneMapped = (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(background.colorSpace) !== (0, $d5b85d29c0b78636$export$8d0a61916cc26abb);
            if (background.matrixAutoUpdate === true) background.updateMatrix();
            planeMesh.material.uniforms.uvTransform.value.copy(background.matrix);
            if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) {
                planeMesh.material.needsUpdate = true;
                currentBackground = background;
                currentBackgroundVersion = background.version;
                currentTonemapping = renderer.toneMapping;
            }
            planeMesh.layers.enableAll();
            // push to the pre-sorted opaque render list
            renderList.unshift(planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null);
        }
    }
    function setClear(color, alpha) {
        color.getRGB($3dd44ec8564e7230$var$_rgb, (0, $d5b85d29c0b78636$export$a630742c640528c1)(renderer));
        state.buffers.color.setClear($3dd44ec8564e7230$var$_rgb.r, $3dd44ec8564e7230$var$_rgb.g, $3dd44ec8564e7230$var$_rgb.b, alpha, premultipliedAlpha);
    }
    function dispose() {
        if (boxMesh !== undefined) {
            boxMesh.geometry.dispose();
            boxMesh.material.dispose();
        }
        if (planeMesh !== undefined) {
            planeMesh.geometry.dispose();
            planeMesh.material.dispose();
        }
    }
    return {
        getClearColor: function() {
            return clearColor;
        },
        setClearColor: function(color, alpha = 1) {
            clearColor.set(color);
            clearAlpha = alpha;
            setClear(clearColor, clearAlpha);
        },
        getClearAlpha: function() {
            return clearAlpha;
        },
        setClearAlpha: function(alpha) {
            clearAlpha = alpha;
            setClear(clearColor, clearAlpha);
        },
        render: render,
        addToRenderList: addToRenderList,
        dispose: dispose
    };
}
function $3dd44ec8564e7230$var$WebGLBindingStates(gl, attributes) {
    const maxVertexAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
    const bindingStates = {};
    const defaultState = createBindingState(null);
    let currentState = defaultState;
    let forceUpdate = false;
    function setup(object, material, program, geometry, index) {
        let updateBuffers = false;
        const state = getBindingState(geometry, program, material);
        if (currentState !== state) {
            currentState = state;
            bindVertexArrayObject(currentState.object);
        }
        updateBuffers = needsUpdate(object, geometry, program, index);
        if (updateBuffers) saveCache(object, geometry, program, index);
        if (index !== null) attributes.update(index, gl.ELEMENT_ARRAY_BUFFER);
        if (updateBuffers || forceUpdate) {
            forceUpdate = false;
            setupVertexAttributes(object, material, program, geometry);
            if (index !== null) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, attributes.get(index).buffer);
        }
    }
    function createVertexArrayObject() {
        return gl.createVertexArray();
    }
    function bindVertexArrayObject(vao) {
        return gl.bindVertexArray(vao);
    }
    function deleteVertexArrayObject(vao) {
        return gl.deleteVertexArray(vao);
    }
    function getBindingState(geometry, program, material) {
        const wireframe = material.wireframe === true;
        let programMap = bindingStates[geometry.id];
        if (programMap === undefined) {
            programMap = {};
            bindingStates[geometry.id] = programMap;
        }
        let stateMap = programMap[program.id];
        if (stateMap === undefined) {
            stateMap = {};
            programMap[program.id] = stateMap;
        }
        let state = stateMap[wireframe];
        if (state === undefined) {
            state = createBindingState(createVertexArrayObject());
            stateMap[wireframe] = state;
        }
        return state;
    }
    function createBindingState(vao) {
        const newAttributes = [];
        const enabledAttributes = [];
        const attributeDivisors = [];
        for(let i = 0; i < maxVertexAttributes; i++){
            newAttributes[i] = 0;
            enabledAttributes[i] = 0;
            attributeDivisors[i] = 0;
        }
        return {
            // for backward compatibility on non-VAO support browser
            geometry: null,
            program: null,
            wireframe: false,
            newAttributes: newAttributes,
            enabledAttributes: enabledAttributes,
            attributeDivisors: attributeDivisors,
            object: vao,
            attributes: {},
            index: null
        };
    }
    function needsUpdate(object, geometry, program, index) {
        const cachedAttributes = currentState.attributes;
        const geometryAttributes = geometry.attributes;
        let attributesNum = 0;
        const programAttributes = program.getAttributes();
        for(const name in programAttributes){
            const programAttribute = programAttributes[name];
            if (programAttribute.location >= 0) {
                const cachedAttribute = cachedAttributes[name];
                let geometryAttribute = geometryAttributes[name];
                if (geometryAttribute === undefined) {
                    if (name === 'instanceMatrix' && object.instanceMatrix) geometryAttribute = object.instanceMatrix;
                    if (name === 'instanceColor' && object.instanceColor) geometryAttribute = object.instanceColor;
                }
                if (cachedAttribute === undefined) return true;
                if (cachedAttribute.attribute !== geometryAttribute) return true;
                if (geometryAttribute && cachedAttribute.data !== geometryAttribute.data) return true;
                attributesNum++;
            }
        }
        if (currentState.attributesNum !== attributesNum) return true;
        if (currentState.index !== index) return true;
        return false;
    }
    function saveCache(object, geometry, program, index) {
        const cache = {};
        const attributes = geometry.attributes;
        let attributesNum = 0;
        const programAttributes = program.getAttributes();
        for(const name in programAttributes){
            const programAttribute = programAttributes[name];
            if (programAttribute.location >= 0) {
                let attribute = attributes[name];
                if (attribute === undefined) {
                    if (name === 'instanceMatrix' && object.instanceMatrix) attribute = object.instanceMatrix;
                    if (name === 'instanceColor' && object.instanceColor) attribute = object.instanceColor;
                }
                const data = {};
                data.attribute = attribute;
                if (attribute && attribute.data) data.data = attribute.data;
                cache[name] = data;
                attributesNum++;
            }
        }
        currentState.attributes = cache;
        currentState.attributesNum = attributesNum;
        currentState.index = index;
    }
    function initAttributes() {
        const newAttributes = currentState.newAttributes;
        for(let i = 0, il = newAttributes.length; i < il; i++)newAttributes[i] = 0;
    }
    function enableAttribute(attribute) {
        enableAttributeAndDivisor(attribute, 0);
    }
    function enableAttributeAndDivisor(attribute, meshPerAttribute) {
        const newAttributes = currentState.newAttributes;
        const enabledAttributes = currentState.enabledAttributes;
        const attributeDivisors = currentState.attributeDivisors;
        newAttributes[attribute] = 1;
        if (enabledAttributes[attribute] === 0) {
            gl.enableVertexAttribArray(attribute);
            enabledAttributes[attribute] = 1;
        }
        if (attributeDivisors[attribute] !== meshPerAttribute) {
            gl.vertexAttribDivisor(attribute, meshPerAttribute);
            attributeDivisors[attribute] = meshPerAttribute;
        }
    }
    function disableUnusedAttributes() {
        const newAttributes = currentState.newAttributes;
        const enabledAttributes = currentState.enabledAttributes;
        for(let i = 0, il = enabledAttributes.length; i < il; i++)if (enabledAttributes[i] !== newAttributes[i]) {
            gl.disableVertexAttribArray(i);
            enabledAttributes[i] = 0;
        }
    }
    function vertexAttribPointer(index, size, type, normalized, stride, offset, integer) {
        if (integer === true) gl.vertexAttribIPointer(index, size, type, stride, offset);
        else gl.vertexAttribPointer(index, size, type, normalized, stride, offset);
    }
    function setupVertexAttributes(object, material, program, geometry) {
        initAttributes();
        const geometryAttributes = geometry.attributes;
        const programAttributes = program.getAttributes();
        const materialDefaultAttributeValues = material.defaultAttributeValues;
        for(const name in programAttributes){
            const programAttribute = programAttributes[name];
            if (programAttribute.location >= 0) {
                let geometryAttribute = geometryAttributes[name];
                if (geometryAttribute === undefined) {
                    if (name === 'instanceMatrix' && object.instanceMatrix) geometryAttribute = object.instanceMatrix;
                    if (name === 'instanceColor' && object.instanceColor) geometryAttribute = object.instanceColor;
                }
                if (geometryAttribute !== undefined) {
                    const normalized = geometryAttribute.normalized;
                    const size = geometryAttribute.itemSize;
                    const attribute = attributes.get(geometryAttribute);
                    // TODO Attribute may not be available on context restore
                    if (attribute === undefined) continue;
                    const buffer = attribute.buffer;
                    const type = attribute.type;
                    const bytesPerElement = attribute.bytesPerElement;
                    // check for integer attributes
                    const integer = type === gl.INT || type === gl.UNSIGNED_INT || geometryAttribute.gpuType === (0, $d5b85d29c0b78636$export$5c612977753abe2);
                    if (geometryAttribute.isInterleavedBufferAttribute) {
                        const data = geometryAttribute.data;
                        const stride = data.stride;
                        const offset = geometryAttribute.offset;
                        if (data.isInstancedInterleavedBuffer) {
                            for(let i = 0; i < programAttribute.locationSize; i++)enableAttributeAndDivisor(programAttribute.location + i, data.meshPerAttribute);
                            if (object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined) geometry._maxInstanceCount = data.meshPerAttribute * data.count;
                        } else for(let i = 0; i < programAttribute.locationSize; i++)enableAttribute(programAttribute.location + i);
                        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
                        for(let i = 0; i < programAttribute.locationSize; i++)vertexAttribPointer(programAttribute.location + i, size / programAttribute.locationSize, type, normalized, stride * bytesPerElement, (offset + size / programAttribute.locationSize * i) * bytesPerElement, integer);
                    } else {
                        if (geometryAttribute.isInstancedBufferAttribute) {
                            for(let i = 0; i < programAttribute.locationSize; i++)enableAttributeAndDivisor(programAttribute.location + i, geometryAttribute.meshPerAttribute);
                            if (object.isInstancedMesh !== true && geometry._maxInstanceCount === undefined) geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
                        } else for(let i = 0; i < programAttribute.locationSize; i++)enableAttribute(programAttribute.location + i);
                        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
                        for(let i = 0; i < programAttribute.locationSize; i++)vertexAttribPointer(programAttribute.location + i, size / programAttribute.locationSize, type, normalized, size * bytesPerElement, size / programAttribute.locationSize * i * bytesPerElement, integer);
                    }
                } else if (materialDefaultAttributeValues !== undefined) {
                    const value = materialDefaultAttributeValues[name];
                    if (value !== undefined) switch(value.length){
                        case 2:
                            gl.vertexAttrib2fv(programAttribute.location, value);
                            break;
                        case 3:
                            gl.vertexAttrib3fv(programAttribute.location, value);
                            break;
                        case 4:
                            gl.vertexAttrib4fv(programAttribute.location, value);
                            break;
                        default:
                            gl.vertexAttrib1fv(programAttribute.location, value);
                    }
                }
            }
        }
        disableUnusedAttributes();
    }
    function dispose() {
        reset();
        for(const geometryId in bindingStates){
            const programMap = bindingStates[geometryId];
            for(const programId in programMap){
                const stateMap = programMap[programId];
                for(const wireframe in stateMap){
                    deleteVertexArrayObject(stateMap[wireframe].object);
                    delete stateMap[wireframe];
                }
                delete programMap[programId];
            }
            delete bindingStates[geometryId];
        }
    }
    function releaseStatesOfGeometry(geometry) {
        if (bindingStates[geometry.id] === undefined) return;
        const programMap = bindingStates[geometry.id];
        for(const programId in programMap){
            const stateMap = programMap[programId];
            for(const wireframe in stateMap){
                deleteVertexArrayObject(stateMap[wireframe].object);
                delete stateMap[wireframe];
            }
            delete programMap[programId];
        }
        delete bindingStates[geometry.id];
    }
    function releaseStatesOfProgram(program) {
        for(const geometryId in bindingStates){
            const programMap = bindingStates[geometryId];
            if (programMap[program.id] === undefined) continue;
            const stateMap = programMap[program.id];
            for(const wireframe in stateMap){
                deleteVertexArrayObject(stateMap[wireframe].object);
                delete stateMap[wireframe];
            }
            delete programMap[program.id];
        }
    }
    function reset() {
        resetDefaultState();
        forceUpdate = true;
        if (currentState === defaultState) return;
        currentState = defaultState;
        bindVertexArrayObject(currentState.object);
    }
    // for backward-compatibility
    function resetDefaultState() {
        defaultState.geometry = null;
        defaultState.program = null;
        defaultState.wireframe = false;
    }
    return {
        setup: setup,
        reset: reset,
        resetDefaultState: resetDefaultState,
        dispose: dispose,
        releaseStatesOfGeometry: releaseStatesOfGeometry,
        releaseStatesOfProgram: releaseStatesOfProgram,
        initAttributes: initAttributes,
        enableAttribute: enableAttribute,
        disableUnusedAttributes: disableUnusedAttributes
    };
}
function $3dd44ec8564e7230$var$WebGLBufferRenderer(gl, extensions, info) {
    let mode;
    function setMode(value) {
        mode = value;
    }
    function render(start, count) {
        gl.drawArrays(mode, start, count);
        info.update(count, mode, 1);
    }
    function renderInstances(start, count, primcount) {
        if (primcount === 0) return;
        gl.drawArraysInstanced(mode, start, count, primcount);
        info.update(count, mode, primcount);
    }
    function renderMultiDraw(starts, counts, drawCount) {
        if (drawCount === 0) return;
        const extension = extensions.get('WEBGL_multi_draw');
        extension.multiDrawArraysWEBGL(mode, starts, 0, counts, 0, drawCount);
        let elementCount = 0;
        for(let i = 0; i < drawCount; i++)elementCount += counts[i];
        info.update(elementCount, mode, 1);
    }
    function renderMultiDrawInstances(starts, counts, drawCount, primcount) {
        if (drawCount === 0) return;
        const extension = extensions.get('WEBGL_multi_draw');
        if (extension === null) for(let i = 0; i < starts.length; i++)renderInstances(starts[i], counts[i], primcount[i]);
        else {
            extension.multiDrawArraysInstancedWEBGL(mode, starts, 0, counts, 0, primcount, 0, drawCount);
            let elementCount = 0;
            for(let i = 0; i < drawCount; i++)elementCount += counts[i] * primcount[i];
            info.update(elementCount, mode, 1);
        }
    }
    //
    this.setMode = setMode;
    this.render = render;
    this.renderInstances = renderInstances;
    this.renderMultiDraw = renderMultiDraw;
    this.renderMultiDrawInstances = renderMultiDrawInstances;
}
function $3dd44ec8564e7230$var$WebGLCapabilities(gl, extensions, parameters, utils) {
    let maxAnisotropy;
    function getMaxAnisotropy() {
        if (maxAnisotropy !== undefined) return maxAnisotropy;
        if (extensions.has('EXT_texture_filter_anisotropic') === true) {
            const extension = extensions.get('EXT_texture_filter_anisotropic');
            maxAnisotropy = gl.getParameter(extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
        } else maxAnisotropy = 0;
        return maxAnisotropy;
    }
    function textureFormatReadable(textureFormat) {
        if (textureFormat !== (0, $d5b85d29c0b78636$export$3f8bb04b555a363c) && utils.convert(textureFormat) !== gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT)) return false;
        return true;
    }
    function textureTypeReadable(textureType) {
        const halfFloatSupportedByExt = textureType === (0, $d5b85d29c0b78636$export$2697304443f382bc) && (extensions.has('EXT_color_buffer_half_float') || extensions.has('EXT_color_buffer_float'));
        if (textureType !== (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10) && utils.convert(textureType) !== gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE) && // Edge and Chrome Mac < 52 (#9513)
        textureType !== (0, $d5b85d29c0b78636$export$f6d331659b644596) && !halfFloatSupportedByExt) return false;
        return true;
    }
    function getMaxPrecision(precision) {
        if (precision === 'highp') {
            if (gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.HIGH_FLOAT).precision > 0 && gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT).precision > 0) return 'highp';
            precision = 'mediump';
        }
        if (precision === 'mediump') {
            if (gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, gl.MEDIUM_FLOAT).precision > 0 && gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT).precision > 0) return 'mediump';
        }
        return 'lowp';
    }
    let precision = parameters.precision !== undefined ? parameters.precision : 'highp';
    const maxPrecision = getMaxPrecision(precision);
    if (maxPrecision !== precision) {
        console.warn('THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.');
        precision = maxPrecision;
    }
    const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;
    const reverseDepthBuffer = parameters.reverseDepthBuffer === true && extensions.has('EXT_clip_control');
    const maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
    const maxVertexTextures = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
    const maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
    const maxCubemapSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE);
    const maxAttributes = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
    const maxVertexUniforms = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS);
    const maxVaryings = gl.getParameter(gl.MAX_VARYING_VECTORS);
    const maxFragmentUniforms = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);
    const vertexTextures = maxVertexTextures > 0;
    const maxSamples = gl.getParameter(gl.MAX_SAMPLES);
    return {
        isWebGL2: true,
        getMaxAnisotropy: getMaxAnisotropy,
        getMaxPrecision: getMaxPrecision,
        textureFormatReadable: textureFormatReadable,
        textureTypeReadable: textureTypeReadable,
        precision: precision,
        logarithmicDepthBuffer: logarithmicDepthBuffer,
        reverseDepthBuffer: reverseDepthBuffer,
        maxTextures: maxTextures,
        maxVertexTextures: maxVertexTextures,
        maxTextureSize: maxTextureSize,
        maxCubemapSize: maxCubemapSize,
        maxAttributes: maxAttributes,
        maxVertexUniforms: maxVertexUniforms,
        maxVaryings: maxVaryings,
        maxFragmentUniforms: maxFragmentUniforms,
        vertexTextures: vertexTextures,
        maxSamples: maxSamples
    };
}
function $3dd44ec8564e7230$var$WebGLClipping(properties) {
    const scope = this;
    let globalState = null, numGlobalPlanes = 0, localClippingEnabled = false, renderingShadows = false;
    const plane = new (0, $d5b85d29c0b78636$export$7ff5ac152ef991b0)(), viewNormalMatrix = new (0, $d5b85d29c0b78636$export$8ff26dafa08918)(), uniform = {
        value: null,
        needsUpdate: false
    };
    this.uniform = uniform;
    this.numPlanes = 0;
    this.numIntersection = 0;
    this.init = function(planes, enableLocalClipping) {
        const enabled = planes.length !== 0 || enableLocalClipping || // enable state of previous frame - the clipping code has to
        // run another frame in order to reset the state:
        numGlobalPlanes !== 0 || localClippingEnabled;
        localClippingEnabled = enableLocalClipping;
        numGlobalPlanes = planes.length;
        return enabled;
    };
    this.beginShadows = function() {
        renderingShadows = true;
        projectPlanes(null);
    };
    this.endShadows = function() {
        renderingShadows = false;
    };
    this.setGlobalState = function(planes, camera) {
        globalState = projectPlanes(planes, camera, 0);
    };
    this.setState = function(material, camera, useCache) {
        const planes = material.clippingPlanes, clipIntersection = material.clipIntersection, clipShadows = material.clipShadows;
        const materialProperties = properties.get(material);
        if (!localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && !clipShadows) {
            // there's no local clipping
            if (renderingShadows) // there's no global clipping
            projectPlanes(null);
            else resetGlobalState();
        } else {
            const nGlobal = renderingShadows ? 0 : numGlobalPlanes, lGlobal = nGlobal * 4;
            let dstArray = materialProperties.clippingState || null;
            uniform.value = dstArray; // ensure unique state
            dstArray = projectPlanes(planes, camera, lGlobal, useCache);
            for(let i = 0; i !== lGlobal; ++i)dstArray[i] = globalState[i];
            materialProperties.clippingState = dstArray;
            this.numIntersection = clipIntersection ? this.numPlanes : 0;
            this.numPlanes += nGlobal;
        }
    };
    function resetGlobalState() {
        if (uniform.value !== globalState) {
            uniform.value = globalState;
            uniform.needsUpdate = numGlobalPlanes > 0;
        }
        scope.numPlanes = numGlobalPlanes;
        scope.numIntersection = 0;
    }
    function projectPlanes(planes, camera, dstOffset, skipTransform) {
        const nPlanes = planes !== null ? planes.length : 0;
        let dstArray = null;
        if (nPlanes !== 0) {
            dstArray = uniform.value;
            if (skipTransform !== true || dstArray === null) {
                const flatSize = dstOffset + nPlanes * 4, viewMatrix = camera.matrixWorldInverse;
                viewNormalMatrix.getNormalMatrix(viewMatrix);
                if (dstArray === null || dstArray.length < flatSize) dstArray = new Float32Array(flatSize);
                for(let i = 0, i4 = dstOffset; i !== nPlanes; ++i, i4 += 4){
                    plane.copy(planes[i]).applyMatrix4(viewMatrix, viewNormalMatrix);
                    plane.normal.toArray(dstArray, i4);
                    dstArray[i4 + 3] = plane.constant;
                }
            }
            uniform.value = dstArray;
            uniform.needsUpdate = true;
        }
        scope.numPlanes = nPlanes;
        scope.numIntersection = 0;
        return dstArray;
    }
}
function $3dd44ec8564e7230$var$WebGLCubeMaps(renderer) {
    let cubemaps = new WeakMap();
    function mapTextureMapping(texture, mapping) {
        if (mapping === (0, $d5b85d29c0b78636$export$d64030b316d3b087)) texture.mapping = (0, $d5b85d29c0b78636$export$8759762a6477f2c4);
        else if (mapping === (0, $d5b85d29c0b78636$export$ee99d97d46898098)) texture.mapping = (0, $d5b85d29c0b78636$export$dc59f8aed047f61d);
        return texture;
    }
    function get(texture) {
        if (texture && texture.isTexture) {
            const mapping = texture.mapping;
            if (mapping === (0, $d5b85d29c0b78636$export$d64030b316d3b087) || mapping === (0, $d5b85d29c0b78636$export$ee99d97d46898098)) {
                if (cubemaps.has(texture)) {
                    const cubemap = cubemaps.get(texture).texture;
                    return mapTextureMapping(cubemap, texture.mapping);
                } else {
                    const image = texture.image;
                    if (image && image.height > 0) {
                        const renderTarget = new (0, $d5b85d29c0b78636$export$ac386671d651941e)(image.height);
                        renderTarget.fromEquirectangularTexture(renderer, texture);
                        cubemaps.set(texture, renderTarget);
                        texture.addEventListener('dispose', onTextureDispose);
                        return mapTextureMapping(renderTarget.texture, texture.mapping);
                    } else // image not yet ready. try the conversion next frame
                    return null;
                }
            }
        }
        return texture;
    }
    function onTextureDispose(event) {
        const texture = event.target;
        texture.removeEventListener('dispose', onTextureDispose);
        const cubemap = cubemaps.get(texture);
        if (cubemap !== undefined) {
            cubemaps.delete(texture);
            cubemap.dispose();
        }
    }
    function dispose() {
        cubemaps = new WeakMap();
    }
    return {
        get: get,
        dispose: dispose
    };
}
const $3dd44ec8564e7230$var$LOD_MIN = 4;
// The standard deviations (radians) associated with the extra mips. These are
// chosen to approximate a Trowbridge-Reitz distribution function times the
// geometric shadowing function. These sigma values squared must match the
// variance #defines in cube_uv_reflection_fragment.glsl.js.
const $3dd44ec8564e7230$var$EXTRA_LOD_SIGMA = [
    0.125,
    0.215,
    0.35,
    0.446,
    0.526,
    0.582
];
// The maximum length of the blur for loop. Smaller sigmas will use fewer
// samples and exit early, but not recompile the shader.
const $3dd44ec8564e7230$var$MAX_SAMPLES = 20;
const $3dd44ec8564e7230$var$_flatCamera = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$9ebf355ee4ed261b)();
const $3dd44ec8564e7230$var$_clearColor = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$892596cec99bc70e)();
let $3dd44ec8564e7230$var$_oldTarget = null;
let $3dd44ec8564e7230$var$_oldActiveCubeFace = 0;
let $3dd44ec8564e7230$var$_oldActiveMipmapLevel = 0;
let $3dd44ec8564e7230$var$_oldXrEnabled = false;
// Golden Ratio
const $3dd44ec8564e7230$var$PHI = (1 + Math.sqrt(5)) / 2;
const $3dd44ec8564e7230$var$INV_PHI = 1 / $3dd44ec8564e7230$var$PHI;
// Vertices of a dodecahedron (except the opposites, which represent the
// same axis), used as axis directions evenly spread on a sphere.
const $3dd44ec8564e7230$var$_axisDirections = [
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(-$3dd44ec8564e7230$var$PHI, $3dd44ec8564e7230$var$INV_PHI, 0),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)($3dd44ec8564e7230$var$PHI, $3dd44ec8564e7230$var$INV_PHI, 0),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(-$3dd44ec8564e7230$var$INV_PHI, 0, $3dd44ec8564e7230$var$PHI),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)($3dd44ec8564e7230$var$INV_PHI, 0, $3dd44ec8564e7230$var$PHI),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(0, $3dd44ec8564e7230$var$PHI, -$3dd44ec8564e7230$var$INV_PHI),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(0, $3dd44ec8564e7230$var$PHI, $3dd44ec8564e7230$var$INV_PHI),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(-1, 1, -1),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(1, 1, -1),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(-1, 1, 1),
    /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(1, 1, 1)
];
/**
 * This class generates a Prefiltered, Mipmapped Radiance Environment Map
 * (PMREM) from a cubeMap environment texture. This allows different levels of
 * blur to be quickly accessed based on material roughness. It is packed into a
 * special CubeUV format that allows us to perform custom interpolation so that
 * we can support nonlinear formats such as RGBE. Unlike a traditional mipmap
 * chain, it only goes down to the LOD_MIN level (above), and then creates extra
 * even more filtered 'mips' at the same LOD_MIN resolution, associated with
 * higher roughness levels. In this way we maintain resolution to smoothly
 * interpolate diffuse lighting while limiting sampling computation.
 *
 * Paper: Fast, Accurate Image-Based Lighting
 * https://drive.google.com/file/d/15y8r_UpKlU9SvV4ILb0C3qCPecS8pvLz/view
*/ class $3dd44ec8564e7230$export$6add42717753e221 {
    constructor(renderer){
        this._renderer = renderer;
        this._pingPongRenderTarget = null;
        this._lodMax = 0;
        this._cubeSize = 0;
        this._lodPlanes = [];
        this._sizeLods = [];
        this._sigmas = [];
        this._blurMaterial = null;
        this._cubemapMaterial = null;
        this._equirectMaterial = null;
        this._compileMaterial(this._blurMaterial);
    }
    /**
	 * Generates a PMREM from a supplied Scene, which can be faster than using an
	 * image if networking bandwidth is low. Optional sigma specifies a blur radius
	 * in radians to be applied to the scene before PMREM generation. Optional near
	 * and far planes ensure the scene is rendered in its entirety (the cubeCamera
	 * is placed at the origin).
	 *
	 * @param {Scene} scene
	 * @param {number} sigma
	 * @param {number} near
	 * @param {number} far
	 * @return {WebGLRenderTarget}
	 */ fromScene(scene, sigma = 0, near = 0.1, far = 100) {
        $3dd44ec8564e7230$var$_oldTarget = this._renderer.getRenderTarget();
        $3dd44ec8564e7230$var$_oldActiveCubeFace = this._renderer.getActiveCubeFace();
        $3dd44ec8564e7230$var$_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
        $3dd44ec8564e7230$var$_oldXrEnabled = this._renderer.xr.enabled;
        this._renderer.xr.enabled = false;
        this._setSize(256);
        const cubeUVRenderTarget = this._allocateTargets();
        cubeUVRenderTarget.depthBuffer = true;
        this._sceneToCubeUV(scene, near, far, cubeUVRenderTarget);
        if (sigma > 0) this._blur(cubeUVRenderTarget, 0, 0, sigma);
        this._applyPMREM(cubeUVRenderTarget);
        this._cleanup(cubeUVRenderTarget);
        return cubeUVRenderTarget;
    }
    /**
	 * Generates a PMREM from an equirectangular texture, which can be either LDR
	 * or HDR. The ideal input image size is 1k (1024 x 512),
	 * as this matches best with the 256 x 256 cubemap output.
	 * The smallest supported equirectangular image size is 64 x 32.
	 *
	 * @param {Texture} equirectangular
	 * @param {WebGLRenderTarget} [renderTarget=null] - Optional render target.
	 * @return {WebGLRenderTarget}
	 */ fromEquirectangular(equirectangular, renderTarget = null) {
        return this._fromTexture(equirectangular, renderTarget);
    }
    /**
	 * Generates a PMREM from an cubemap texture, which can be either LDR
	 * or HDR. The ideal input cube size is 256 x 256,
	 * as this matches best with the 256 x 256 cubemap output.
	 * The smallest supported cube size is 16 x 16.
	 *
	 * @param {Texture} cubemap
	 * @param {null} [renderTarget=null] - Optional render target.
	 * @return {WebGLRenderTarget}
	 */ fromCubemap(cubemap, renderTarget = null) {
        return this._fromTexture(cubemap, renderTarget);
    }
    /**
	 * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during
	 * your texture's network fetch for increased concurrency.
	 */ compileCubemapShader() {
        if (this._cubemapMaterial === null) {
            this._cubemapMaterial = $3dd44ec8564e7230$var$_getCubemapMaterial();
            this._compileMaterial(this._cubemapMaterial);
        }
    }
    /**
	 * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during
	 * your texture's network fetch for increased concurrency.
	 */ compileEquirectangularShader() {
        if (this._equirectMaterial === null) {
            this._equirectMaterial = $3dd44ec8564e7230$var$_getEquirectMaterial();
            this._compileMaterial(this._equirectMaterial);
        }
    }
    /**
	 * Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class,
	 * so you should not need more than one PMREMGenerator object. If you do, calling dispose() on
	 * one of them will cause any others to also become unusable.
	 */ dispose() {
        this._dispose();
        if (this._cubemapMaterial !== null) this._cubemapMaterial.dispose();
        if (this._equirectMaterial !== null) this._equirectMaterial.dispose();
    }
    // private interface
    _setSize(cubeSize) {
        this._lodMax = Math.floor(Math.log2(cubeSize));
        this._cubeSize = Math.pow(2, this._lodMax);
    }
    _dispose() {
        if (this._blurMaterial !== null) this._blurMaterial.dispose();
        if (this._pingPongRenderTarget !== null) this._pingPongRenderTarget.dispose();
        for(let i = 0; i < this._lodPlanes.length; i++)this._lodPlanes[i].dispose();
    }
    _cleanup(outputTarget) {
        this._renderer.setRenderTarget($3dd44ec8564e7230$var$_oldTarget, $3dd44ec8564e7230$var$_oldActiveCubeFace, $3dd44ec8564e7230$var$_oldActiveMipmapLevel);
        this._renderer.xr.enabled = $3dd44ec8564e7230$var$_oldXrEnabled;
        outputTarget.scissorTest = false;
        $3dd44ec8564e7230$var$_setViewport(outputTarget, 0, 0, outputTarget.width, outputTarget.height);
    }
    _fromTexture(texture, renderTarget) {
        if (texture.mapping === (0, $d5b85d29c0b78636$export$8759762a6477f2c4) || texture.mapping === (0, $d5b85d29c0b78636$export$dc59f8aed047f61d)) this._setSize(texture.image.length === 0 ? 16 : texture.image[0].width || texture.image[0].image.width);
        else this._setSize(texture.image.width / 4);
        $3dd44ec8564e7230$var$_oldTarget = this._renderer.getRenderTarget();
        $3dd44ec8564e7230$var$_oldActiveCubeFace = this._renderer.getActiveCubeFace();
        $3dd44ec8564e7230$var$_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
        $3dd44ec8564e7230$var$_oldXrEnabled = this._renderer.xr.enabled;
        this._renderer.xr.enabled = false;
        const cubeUVRenderTarget = renderTarget || this._allocateTargets();
        this._textureToCubeUV(texture, cubeUVRenderTarget);
        this._applyPMREM(cubeUVRenderTarget);
        this._cleanup(cubeUVRenderTarget);
        return cubeUVRenderTarget;
    }
    _allocateTargets() {
        const width = 3 * Math.max(this._cubeSize, 112);
        const height = 4 * this._cubeSize;
        const params = {
            magFilter: (0, $d5b85d29c0b78636$export$8a72f490b25c56c8),
            minFilter: (0, $d5b85d29c0b78636$export$8a72f490b25c56c8),
            generateMipmaps: false,
            type: (0, $d5b85d29c0b78636$export$2697304443f382bc),
            format: (0, $d5b85d29c0b78636$export$3f8bb04b555a363c),
            colorSpace: (0, $d5b85d29c0b78636$export$42429b3acfb233a4),
            depthBuffer: false
        };
        const cubeUVRenderTarget = $3dd44ec8564e7230$var$_createRenderTarget(width, height, params);
        if (this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== width || this._pingPongRenderTarget.height !== height) {
            if (this._pingPongRenderTarget !== null) this._dispose();
            this._pingPongRenderTarget = $3dd44ec8564e7230$var$_createRenderTarget(width, height, params);
            const { _lodMax: _lodMax } = this;
            ({ sizeLods: this._sizeLods, lodPlanes: this._lodPlanes, sigmas: this._sigmas } = $3dd44ec8564e7230$var$_createPlanes(_lodMax));
            this._blurMaterial = $3dd44ec8564e7230$var$_getBlurShader(_lodMax, width, height);
        }
        return cubeUVRenderTarget;
    }
    _compileMaterial(material) {
        const tmpMesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(this._lodPlanes[0], material);
        this._renderer.compile(tmpMesh, $3dd44ec8564e7230$var$_flatCamera);
    }
    _sceneToCubeUV(scene, near, far, cubeUVRenderTarget) {
        const fov = 90;
        const aspect = 1;
        const cubeCamera = new (0, $d5b85d29c0b78636$export$74e4ae24825f68d7)(fov, aspect, near, far);
        const upSign = [
            1,
            -1,
            1,
            1,
            1,
            1
        ];
        const forwardSign = [
            1,
            1,
            1,
            -1,
            -1,
            -1
        ];
        const renderer = this._renderer;
        const originalAutoClear = renderer.autoClear;
        const toneMapping = renderer.toneMapping;
        renderer.getClearColor($3dd44ec8564e7230$var$_clearColor);
        renderer.toneMapping = (0, $d5b85d29c0b78636$export$9fcb6b4294603b2);
        renderer.autoClear = false;
        const backgroundMaterial = new (0, $d5b85d29c0b78636$export$55cbcc9b622fe1f5)({
            name: 'PMREM.Background',
            side: (0, $d5b85d29c0b78636$export$d9f0486e75b5ace),
            depthWrite: false,
            depthTest: false
        });
        const backgroundBox = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(new (0, $d5b85d29c0b78636$export$33e43285f7406bd5)(), backgroundMaterial);
        let useSolidColor = false;
        const background = scene.background;
        if (background) {
            if (background.isColor) {
                backgroundMaterial.color.copy(background);
                scene.background = null;
                useSolidColor = true;
            }
        } else {
            backgroundMaterial.color.copy($3dd44ec8564e7230$var$_clearColor);
            useSolidColor = true;
        }
        for(let i = 0; i < 6; i++){
            const col = i % 3;
            if (col === 0) {
                cubeCamera.up.set(0, upSign[i], 0);
                cubeCamera.lookAt(forwardSign[i], 0, 0);
            } else if (col === 1) {
                cubeCamera.up.set(0, 0, upSign[i]);
                cubeCamera.lookAt(0, forwardSign[i], 0);
            } else {
                cubeCamera.up.set(0, upSign[i], 0);
                cubeCamera.lookAt(0, 0, forwardSign[i]);
            }
            const size = this._cubeSize;
            $3dd44ec8564e7230$var$_setViewport(cubeUVRenderTarget, col * size, i > 2 ? size : 0, size, size);
            renderer.setRenderTarget(cubeUVRenderTarget);
            if (useSolidColor) renderer.render(backgroundBox, cubeCamera);
            renderer.render(scene, cubeCamera);
        }
        backgroundBox.geometry.dispose();
        backgroundBox.material.dispose();
        renderer.toneMapping = toneMapping;
        renderer.autoClear = originalAutoClear;
        scene.background = background;
    }
    _textureToCubeUV(texture, cubeUVRenderTarget) {
        const renderer = this._renderer;
        const isCubeTexture = texture.mapping === (0, $d5b85d29c0b78636$export$8759762a6477f2c4) || texture.mapping === (0, $d5b85d29c0b78636$export$dc59f8aed047f61d);
        if (isCubeTexture) {
            if (this._cubemapMaterial === null) this._cubemapMaterial = $3dd44ec8564e7230$var$_getCubemapMaterial();
            this._cubemapMaterial.uniforms.flipEnvMap.value = texture.isRenderTargetTexture === false ? -1 : 1;
        } else if (this._equirectMaterial === null) this._equirectMaterial = $3dd44ec8564e7230$var$_getEquirectMaterial();
        const material = isCubeTexture ? this._cubemapMaterial : this._equirectMaterial;
        const mesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(this._lodPlanes[0], material);
        const uniforms = material.uniforms;
        uniforms['envMap'].value = texture;
        const size = this._cubeSize;
        $3dd44ec8564e7230$var$_setViewport(cubeUVRenderTarget, 0, 0, 3 * size, 2 * size);
        renderer.setRenderTarget(cubeUVRenderTarget);
        renderer.render(mesh, $3dd44ec8564e7230$var$_flatCamera);
    }
    _applyPMREM(cubeUVRenderTarget) {
        const renderer = this._renderer;
        const autoClear = renderer.autoClear;
        renderer.autoClear = false;
        const n = this._lodPlanes.length;
        for(let i = 1; i < n; i++){
            const sigma = Math.sqrt(this._sigmas[i] * this._sigmas[i] - this._sigmas[i - 1] * this._sigmas[i - 1]);
            const poleAxis = $3dd44ec8564e7230$var$_axisDirections[(n - i - 1) % $3dd44ec8564e7230$var$_axisDirections.length];
            this._blur(cubeUVRenderTarget, i - 1, i, sigma, poleAxis);
        }
        renderer.autoClear = autoClear;
    }
    /**
	 * This is a two-pass Gaussian blur for a cubemap. Normally this is done
	 * vertically and horizontally, but this breaks down on a cube. Here we apply
	 * the blur latitudinally (around the poles), and then longitudinally (towards
	 * the poles) to approximate the orthogonally-separable blur. It is least
	 * accurate at the poles, but still does a decent job.
	 *
	 * @param {WebGLRenderTarget} cubeUVRenderTarget
	 * @param {number} lodIn
	 * @param {number} lodOut
	 * @param {number} sigma
	 * @param {Vector3} [poleAxis]
	 */ _blur(cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis) {
        const pingPongRenderTarget = this._pingPongRenderTarget;
        this._halfBlur(cubeUVRenderTarget, pingPongRenderTarget, lodIn, lodOut, sigma, 'latitudinal', poleAxis);
        this._halfBlur(pingPongRenderTarget, cubeUVRenderTarget, lodOut, lodOut, sigma, 'longitudinal', poleAxis);
    }
    _halfBlur(targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis) {
        const renderer = this._renderer;
        const blurMaterial = this._blurMaterial;
        if (direction !== 'latitudinal' && direction !== 'longitudinal') console.error('blur direction must be either latitudinal or longitudinal!');
        // Number of standard deviations at which to cut off the discrete approximation.
        const STANDARD_DEVIATIONS = 3;
        const blurMesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(this._lodPlanes[lodOut], blurMaterial);
        const blurUniforms = blurMaterial.uniforms;
        const pixels = this._sizeLods[lodIn] - 1;
        const radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : 2 * Math.PI / (2 * $3dd44ec8564e7230$var$MAX_SAMPLES - 1);
        const sigmaPixels = sigmaRadians / radiansPerPixel;
        const samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : $3dd44ec8564e7230$var$MAX_SAMPLES;
        if (samples > $3dd44ec8564e7230$var$MAX_SAMPLES) console.warn(`sigmaRadians, ${sigmaRadians}, is too large and will clip, as it requested ${samples} samples when the maximum is set to ${$3dd44ec8564e7230$var$MAX_SAMPLES}`);
        const weights = [];
        let sum = 0;
        for(let i = 0; i < $3dd44ec8564e7230$var$MAX_SAMPLES; ++i){
            const x = i / sigmaPixels;
            const weight = Math.exp(-x * x / 2);
            weights.push(weight);
            if (i === 0) sum += weight;
            else if (i < samples) sum += 2 * weight;
        }
        for(let i = 0; i < weights.length; i++)weights[i] = weights[i] / sum;
        blurUniforms['envMap'].value = targetIn.texture;
        blurUniforms['samples'].value = samples;
        blurUniforms['weights'].value = weights;
        blurUniforms['latitudinal'].value = direction === 'latitudinal';
        if (poleAxis) blurUniforms['poleAxis'].value = poleAxis;
        const { _lodMax: _lodMax } = this;
        blurUniforms['dTheta'].value = radiansPerPixel;
        blurUniforms['mipInt'].value = _lodMax - lodIn;
        const outputSize = this._sizeLods[lodOut];
        const x = 3 * outputSize * (lodOut > _lodMax - $3dd44ec8564e7230$var$LOD_MIN ? lodOut - _lodMax + $3dd44ec8564e7230$var$LOD_MIN : 0);
        const y = 4 * (this._cubeSize - outputSize);
        $3dd44ec8564e7230$var$_setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize);
        renderer.setRenderTarget(targetOut);
        renderer.render(blurMesh, $3dd44ec8564e7230$var$_flatCamera);
    }
}
function $3dd44ec8564e7230$var$_createPlanes(lodMax) {
    const lodPlanes = [];
    const sizeLods = [];
    const sigmas = [];
    let lod = lodMax;
    const totalLods = lodMax - $3dd44ec8564e7230$var$LOD_MIN + 1 + $3dd44ec8564e7230$var$EXTRA_LOD_SIGMA.length;
    for(let i = 0; i < totalLods; i++){
        const sizeLod = Math.pow(2, lod);
        sizeLods.push(sizeLod);
        let sigma = 1.0 / sizeLod;
        if (i > lodMax - $3dd44ec8564e7230$var$LOD_MIN) sigma = $3dd44ec8564e7230$var$EXTRA_LOD_SIGMA[i - lodMax + $3dd44ec8564e7230$var$LOD_MIN - 1];
        else if (i === 0) sigma = 0;
        sigmas.push(sigma);
        const texelSize = 1.0 / (sizeLod - 2);
        const min = -texelSize;
        const max = 1 + texelSize;
        const uv1 = [
            min,
            min,
            max,
            min,
            max,
            max,
            min,
            min,
            max,
            max,
            min,
            max
        ];
        const cubeFaces = 6;
        const vertices = 6;
        const positionSize = 3;
        const uvSize = 2;
        const faceIndexSize = 1;
        const position = new Float32Array(positionSize * vertices * cubeFaces);
        const uv = new Float32Array(uvSize * vertices * cubeFaces);
        const faceIndex = new Float32Array(faceIndexSize * vertices * cubeFaces);
        for(let face = 0; face < cubeFaces; face++){
            const x = face % 3 * 2 / 3 - 1;
            const y = face > 2 ? 0 : -1;
            const coordinates = [
                x,
                y,
                0,
                x + 2 / 3,
                y,
                0,
                x + 2 / 3,
                y + 1,
                0,
                x,
                y,
                0,
                x + 2 / 3,
                y + 1,
                0,
                x,
                y + 1,
                0
            ];
            position.set(coordinates, positionSize * vertices * face);
            uv.set(uv1, uvSize * vertices * face);
            const fill = [
                face,
                face,
                face,
                face,
                face,
                face
            ];
            faceIndex.set(fill, faceIndexSize * vertices * face);
        }
        const planes = new (0, $d5b85d29c0b78636$export$b7be63a67df8959)();
        planes.setAttribute('position', new (0, $d5b85d29c0b78636$export$8dea267bd6bde117)(position, positionSize));
        planes.setAttribute('uv', new (0, $d5b85d29c0b78636$export$8dea267bd6bde117)(uv, uvSize));
        planes.setAttribute('faceIndex', new (0, $d5b85d29c0b78636$export$8dea267bd6bde117)(faceIndex, faceIndexSize));
        lodPlanes.push(planes);
        if (lod > $3dd44ec8564e7230$var$LOD_MIN) lod--;
    }
    return {
        lodPlanes: lodPlanes,
        sizeLods: sizeLods,
        sigmas: sigmas
    };
}
function $3dd44ec8564e7230$var$_createRenderTarget(width, height, params) {
    const cubeUVRenderTarget = new (0, $d5b85d29c0b78636$export$3c052beb2e51e23f)(width, height, params);
    cubeUVRenderTarget.texture.mapping = (0, $d5b85d29c0b78636$export$dbf3e70ff37af79);
    cubeUVRenderTarget.texture.name = 'PMREM.cubeUv';
    cubeUVRenderTarget.scissorTest = true;
    return cubeUVRenderTarget;
}
function $3dd44ec8564e7230$var$_setViewport(target, x, y, width, height) {
    target.viewport.set(x, y, width, height);
    target.scissor.set(x, y, width, height);
}
function $3dd44ec8564e7230$var$_getBlurShader(lodMax, width, height) {
    const weights = new Float32Array($3dd44ec8564e7230$var$MAX_SAMPLES);
    const poleAxis = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(0, 1, 0);
    const shaderMaterial = new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
        name: 'SphericalGaussianBlur',
        defines: {
            'n': $3dd44ec8564e7230$var$MAX_SAMPLES,
            'CUBEUV_TEXEL_WIDTH': 1.0 / width,
            'CUBEUV_TEXEL_HEIGHT': 1.0 / height,
            'CUBEUV_MAX_MIP': `${lodMax}.0`
        },
        uniforms: {
            'envMap': {
                value: null
            },
            'samples': {
                value: 1
            },
            'weights': {
                value: weights
            },
            'latitudinal': {
                value: false
            },
            'dTheta': {
                value: 0
            },
            'mipInt': {
                value: 0
            },
            'poleAxis': {
                value: poleAxis
            }
        },
        vertexShader: $3dd44ec8564e7230$var$_getCommonVertexShader(),
        fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;
			uniform int samples;
			uniform float weights[ n ];
			uniform bool latitudinal;
			uniform float dTheta;
			uniform float mipInt;
			uniform vec3 poleAxis;

			#define ENVMAP_TYPE_CUBE_UV
			#include <cube_uv_reflection_fragment>

			vec3 getSample( float theta, vec3 axis ) {

				float cosTheta = cos( theta );
				// Rodrigues' axis-angle rotation
				vec3 sampleDirection = vOutputDirection * cosTheta
					+ cross( axis, vOutputDirection ) * sin( theta )
					+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );

				return bilinearCubeUV( envMap, sampleDirection, mipInt );

			}

			void main() {

				vec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );

				if ( all( equal( axis, vec3( 0.0 ) ) ) ) {

					axis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );

				}

				axis = normalize( axis );

				gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );
				gl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );

				for ( int i = 1; i < n; i++ ) {

					if ( i >= samples ) {

						break;

					}

					float theta = dTheta * float( i );
					gl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );
					gl_FragColor.rgb += weights[ i ] * getSample( theta, axis );

				}

			}
		`,
        blending: (0, $d5b85d29c0b78636$export$63b8d6b580fc65ba),
        depthTest: false,
        depthWrite: false
    });
    return shaderMaterial;
}
function $3dd44ec8564e7230$var$_getEquirectMaterial() {
    return new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
        name: 'EquirectangularToCubeUV',
        uniforms: {
            'envMap': {
                value: null
            }
        },
        vertexShader: $3dd44ec8564e7230$var$_getCommonVertexShader(),
        fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			varying vec3 vOutputDirection;

			uniform sampler2D envMap;

			#include <common>

			void main() {

				vec3 outputDirection = normalize( vOutputDirection );
				vec2 uv = equirectUv( outputDirection );

				gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 );

			}
		`,
        blending: (0, $d5b85d29c0b78636$export$63b8d6b580fc65ba),
        depthTest: false,
        depthWrite: false
    });
}
function $3dd44ec8564e7230$var$_getCubemapMaterial() {
    return new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
        name: 'CubemapToCubeUV',
        uniforms: {
            'envMap': {
                value: null
            },
            'flipEnvMap': {
                value: -1
            }
        },
        vertexShader: $3dd44ec8564e7230$var$_getCommonVertexShader(),
        fragmentShader: /* glsl */ `

			precision mediump float;
			precision mediump int;

			uniform float flipEnvMap;

			varying vec3 vOutputDirection;

			uniform samplerCube envMap;

			void main() {

				gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) );

			}
		`,
        blending: (0, $d5b85d29c0b78636$export$63b8d6b580fc65ba),
        depthTest: false,
        depthWrite: false
    });
}
function $3dd44ec8564e7230$var$_getCommonVertexShader() {
    return /* glsl */ `

		precision mediump float;
		precision mediump int;

		attribute float faceIndex;

		varying vec3 vOutputDirection;

		// RH coordinate system; PMREM face-indexing convention
		vec3 getDirection( vec2 uv, float face ) {

			uv = 2.0 * uv - 1.0;

			vec3 direction = vec3( uv, 1.0 );

			if ( face == 0.0 ) {

				direction = direction.zyx; // ( 1, v, u ) pos x

			} else if ( face == 1.0 ) {

				direction = direction.xzy;
				direction.xz *= -1.0; // ( -u, 1, -v ) pos y

			} else if ( face == 2.0 ) {

				direction.x *= -1.0; // ( -u, v, 1 ) pos z

			} else if ( face == 3.0 ) {

				direction = direction.zyx;
				direction.xz *= -1.0; // ( -1, v, -u ) neg x

			} else if ( face == 4.0 ) {

				direction = direction.xzy;
				direction.xy *= -1.0; // ( -u, -1, v ) neg y

			} else if ( face == 5.0 ) {

				direction.z *= -1.0; // ( u, v, -1 ) neg z

			}

			return direction;

		}

		void main() {

			vOutputDirection = getDirection( uv, faceIndex );
			gl_Position = vec4( position, 1.0 );

		}
	`;
}
function $3dd44ec8564e7230$var$WebGLCubeUVMaps(renderer) {
    let cubeUVmaps = new WeakMap();
    let pmremGenerator = null;
    function get(texture) {
        if (texture && texture.isTexture) {
            const mapping = texture.mapping;
            const isEquirectMap = mapping === (0, $d5b85d29c0b78636$export$d64030b316d3b087) || mapping === (0, $d5b85d29c0b78636$export$ee99d97d46898098);
            const isCubeMap = mapping === (0, $d5b85d29c0b78636$export$8759762a6477f2c4) || mapping === (0, $d5b85d29c0b78636$export$dc59f8aed047f61d);
            // equirect/cube map to cubeUV conversion
            if (isEquirectMap || isCubeMap) {
                let renderTarget = cubeUVmaps.get(texture);
                const currentPMREMVersion = renderTarget !== undefined ? renderTarget.texture.pmremVersion : 0;
                if (texture.isRenderTargetTexture && texture.pmremVersion !== currentPMREMVersion) {
                    if (pmremGenerator === null) pmremGenerator = new $3dd44ec8564e7230$export$6add42717753e221(renderer);
                    renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular(texture, renderTarget) : pmremGenerator.fromCubemap(texture, renderTarget);
                    renderTarget.texture.pmremVersion = texture.pmremVersion;
                    cubeUVmaps.set(texture, renderTarget);
                    return renderTarget.texture;
                } else {
                    if (renderTarget !== undefined) return renderTarget.texture;
                    else {
                        const image = texture.image;
                        if (isEquirectMap && image && image.height > 0 || isCubeMap && image && isCubeTextureComplete(image)) {
                            if (pmremGenerator === null) pmremGenerator = new $3dd44ec8564e7230$export$6add42717753e221(renderer);
                            renderTarget = isEquirectMap ? pmremGenerator.fromEquirectangular(texture) : pmremGenerator.fromCubemap(texture);
                            renderTarget.texture.pmremVersion = texture.pmremVersion;
                            cubeUVmaps.set(texture, renderTarget);
                            texture.addEventListener('dispose', onTextureDispose);
                            return renderTarget.texture;
                        } else // image not yet ready. try the conversion next frame
                        return null;
                    }
                }
            }
        }
        return texture;
    }
    function isCubeTextureComplete(image) {
        let count = 0;
        const length = 6;
        for(let i = 0; i < length; i++)if (image[i] !== undefined) count++;
        return count === length;
    }
    function onTextureDispose(event) {
        const texture = event.target;
        texture.removeEventListener('dispose', onTextureDispose);
        const cubemapUV = cubeUVmaps.get(texture);
        if (cubemapUV !== undefined) {
            cubeUVmaps.delete(texture);
            cubemapUV.dispose();
        }
    }
    function dispose() {
        cubeUVmaps = new WeakMap();
        if (pmremGenerator !== null) {
            pmremGenerator.dispose();
            pmremGenerator = null;
        }
    }
    return {
        get: get,
        dispose: dispose
    };
}
function $3dd44ec8564e7230$var$WebGLExtensions(gl) {
    const extensions = {};
    function getExtension(name) {
        if (extensions[name] !== undefined) return extensions[name];
        let extension;
        switch(name){
            case 'WEBGL_depth_texture':
                extension = gl.getExtension('WEBGL_depth_texture') || gl.getExtension('MOZ_WEBGL_depth_texture') || gl.getExtension('WEBKIT_WEBGL_depth_texture');
                break;
            case 'EXT_texture_filter_anisotropic':
                extension = gl.getExtension('EXT_texture_filter_anisotropic') || gl.getExtension('MOZ_EXT_texture_filter_anisotropic') || gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic');
                break;
            case 'WEBGL_compressed_texture_s3tc':
                extension = gl.getExtension('WEBGL_compressed_texture_s3tc') || gl.getExtension('MOZ_WEBGL_compressed_texture_s3tc') || gl.getExtension('WEBKIT_WEBGL_compressed_texture_s3tc');
                break;
            case 'WEBGL_compressed_texture_pvrtc':
                extension = gl.getExtension('WEBGL_compressed_texture_pvrtc') || gl.getExtension('WEBKIT_WEBGL_compressed_texture_pvrtc');
                break;
            default:
                extension = gl.getExtension(name);
        }
        extensions[name] = extension;
        return extension;
    }
    return {
        has: function(name) {
            return getExtension(name) !== null;
        },
        init: function() {
            getExtension('EXT_color_buffer_float');
            getExtension('WEBGL_clip_cull_distance');
            getExtension('OES_texture_float_linear');
            getExtension('EXT_color_buffer_half_float');
            getExtension('WEBGL_multisampled_render_to_texture');
            getExtension('WEBGL_render_shared_exponent');
        },
        get: function(name) {
            const extension = getExtension(name);
            if (extension === null) (0, $d5b85d29c0b78636$export$5b28268982f175ba)('THREE.WebGLRenderer: ' + name + ' extension not supported.');
            return extension;
        }
    };
}
function $3dd44ec8564e7230$var$WebGLGeometries(gl, attributes, info, bindingStates) {
    const geometries = {};
    const wireframeAttributes = new WeakMap();
    function onGeometryDispose(event) {
        const geometry = event.target;
        if (geometry.index !== null) attributes.remove(geometry.index);
        for(const name in geometry.attributes)attributes.remove(geometry.attributes[name]);
        geometry.removeEventListener('dispose', onGeometryDispose);
        delete geometries[geometry.id];
        const attribute = wireframeAttributes.get(geometry);
        if (attribute) {
            attributes.remove(attribute);
            wireframeAttributes.delete(geometry);
        }
        bindingStates.releaseStatesOfGeometry(geometry);
        if (geometry.isInstancedBufferGeometry === true) delete geometry._maxInstanceCount;
        //
        info.memory.geometries--;
    }
    function get(object, geometry) {
        if (geometries[geometry.id] === true) return geometry;
        geometry.addEventListener('dispose', onGeometryDispose);
        geometries[geometry.id] = true;
        info.memory.geometries++;
        return geometry;
    }
    function update(geometry) {
        const geometryAttributes = geometry.attributes;
        // Updating index buffer in VAO now. See WebGLBindingStates.
        for(const name in geometryAttributes)attributes.update(geometryAttributes[name], gl.ARRAY_BUFFER);
    }
    function updateWireframeAttribute(geometry) {
        const indices = [];
        const geometryIndex = geometry.index;
        const geometryPosition = geometry.attributes.position;
        let version = 0;
        if (geometryIndex !== null) {
            const array = geometryIndex.array;
            version = geometryIndex.version;
            for(let i = 0, l = array.length; i < l; i += 3){
                const a = array[i + 0];
                const b = array[i + 1];
                const c = array[i + 2];
                indices.push(a, b, b, c, c, a);
            }
        } else if (geometryPosition !== undefined) {
            const array = geometryPosition.array;
            version = geometryPosition.version;
            for(let i = 0, l = array.length / 3 - 1; i < l; i += 3){
                const a = i + 0;
                const b = i + 1;
                const c = i + 2;
                indices.push(a, b, b, c, c, a);
            }
        } else return;
        const attribute = new ((0, $d5b85d29c0b78636$export$bc6f937da07eae17)(indices) ? (0, $d5b85d29c0b78636$export$7eb8c9fa25cd5bd6) : (0, $d5b85d29c0b78636$export$640a853f68025f2e))(indices, 1);
        attribute.version = version;
        // Updating index buffer in VAO now. See WebGLBindingStates
        //
        const previousAttribute = wireframeAttributes.get(geometry);
        if (previousAttribute) attributes.remove(previousAttribute);
        //
        wireframeAttributes.set(geometry, attribute);
    }
    function getWireframeAttribute(geometry) {
        const currentAttribute = wireframeAttributes.get(geometry);
        if (currentAttribute) {
            const geometryIndex = geometry.index;
            if (geometryIndex !== null) // if the attribute is obsolete, create a new one
            {
                if (currentAttribute.version < geometryIndex.version) updateWireframeAttribute(geometry);
            }
        } else updateWireframeAttribute(geometry);
        return wireframeAttributes.get(geometry);
    }
    return {
        get: get,
        update: update,
        getWireframeAttribute: getWireframeAttribute
    };
}
function $3dd44ec8564e7230$var$WebGLIndexedBufferRenderer(gl, extensions, info) {
    let mode;
    function setMode(value) {
        mode = value;
    }
    let type, bytesPerElement;
    function setIndex(value) {
        type = value.type;
        bytesPerElement = value.bytesPerElement;
    }
    function render(start, count) {
        gl.drawElements(mode, count, type, start * bytesPerElement);
        info.update(count, mode, 1);
    }
    function renderInstances(start, count, primcount) {
        if (primcount === 0) return;
        gl.drawElementsInstanced(mode, count, type, start * bytesPerElement, primcount);
        info.update(count, mode, primcount);
    }
    function renderMultiDraw(starts, counts, drawCount) {
        if (drawCount === 0) return;
        const extension = extensions.get('WEBGL_multi_draw');
        extension.multiDrawElementsWEBGL(mode, counts, 0, type, starts, 0, drawCount);
        let elementCount = 0;
        for(let i = 0; i < drawCount; i++)elementCount += counts[i];
        info.update(elementCount, mode, 1);
    }
    function renderMultiDrawInstances(starts, counts, drawCount, primcount) {
        if (drawCount === 0) return;
        const extension = extensions.get('WEBGL_multi_draw');
        if (extension === null) for(let i = 0; i < starts.length; i++)renderInstances(starts[i] / bytesPerElement, counts[i], primcount[i]);
        else {
            extension.multiDrawElementsInstancedWEBGL(mode, counts, 0, type, starts, 0, primcount, 0, drawCount);
            let elementCount = 0;
            for(let i = 0; i < drawCount; i++)elementCount += counts[i] * primcount[i];
            info.update(elementCount, mode, 1);
        }
    }
    //
    this.setMode = setMode;
    this.setIndex = setIndex;
    this.render = render;
    this.renderInstances = renderInstances;
    this.renderMultiDraw = renderMultiDraw;
    this.renderMultiDrawInstances = renderMultiDrawInstances;
}
function $3dd44ec8564e7230$var$WebGLInfo(gl) {
    const memory = {
        geometries: 0,
        textures: 0
    };
    const render = {
        frame: 0,
        calls: 0,
        triangles: 0,
        points: 0,
        lines: 0
    };
    function update(count, mode, instanceCount) {
        render.calls++;
        switch(mode){
            case gl.TRIANGLES:
                render.triangles += instanceCount * (count / 3);
                break;
            case gl.LINES:
                render.lines += instanceCount * (count / 2);
                break;
            case gl.LINE_STRIP:
                render.lines += instanceCount * (count - 1);
                break;
            case gl.LINE_LOOP:
                render.lines += instanceCount * count;
                break;
            case gl.POINTS:
                render.points += instanceCount * count;
                break;
            default:
                console.error('THREE.WebGLInfo: Unknown draw mode:', mode);
                break;
        }
    }
    function reset() {
        render.calls = 0;
        render.triangles = 0;
        render.points = 0;
        render.lines = 0;
    }
    return {
        memory: memory,
        render: render,
        programs: null,
        autoReset: true,
        reset: reset,
        update: update
    };
}
function $3dd44ec8564e7230$var$WebGLMorphtargets(gl, capabilities, textures) {
    const morphTextures = new WeakMap();
    const morph = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
    function update(object, geometry, program) {
        const objectInfluences = object.morphTargetInfluences;
        // the following encodes morph targets into an array of data textures. Each layer represents a single morph target.
        const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
        const morphTargetsCount = morphAttribute !== undefined ? morphAttribute.length : 0;
        let entry = morphTextures.get(geometry);
        if (entry === undefined || entry.count !== morphTargetsCount) {
            if (entry !== undefined) entry.texture.dispose();
            const hasMorphPosition = geometry.morphAttributes.position !== undefined;
            const hasMorphNormals = geometry.morphAttributes.normal !== undefined;
            const hasMorphColors = geometry.morphAttributes.color !== undefined;
            const morphTargets = geometry.morphAttributes.position || [];
            const morphNormals = geometry.morphAttributes.normal || [];
            const morphColors = geometry.morphAttributes.color || [];
            let vertexDataCount = 0;
            if (hasMorphPosition === true) vertexDataCount = 1;
            if (hasMorphNormals === true) vertexDataCount = 2;
            if (hasMorphColors === true) vertexDataCount = 3;
            let width = geometry.attributes.position.count * vertexDataCount;
            let height = 1;
            if (width > capabilities.maxTextureSize) {
                height = Math.ceil(width / capabilities.maxTextureSize);
                width = capabilities.maxTextureSize;
            }
            const buffer = new Float32Array(width * height * 4 * morphTargetsCount);
            const texture = new (0, $d5b85d29c0b78636$export$dfac6c8e811406a3)(buffer, width, height, morphTargetsCount);
            texture.type = (0, $d5b85d29c0b78636$export$f6d331659b644596);
            texture.needsUpdate = true;
            // fill buffer
            const vertexDataStride = vertexDataCount * 4;
            for(let i = 0; i < morphTargetsCount; i++){
                const morphTarget = morphTargets[i];
                const morphNormal = morphNormals[i];
                const morphColor = morphColors[i];
                const offset = width * height * 4 * i;
                for(let j = 0; j < morphTarget.count; j++){
                    const stride = j * vertexDataStride;
                    if (hasMorphPosition === true) {
                        morph.fromBufferAttribute(morphTarget, j);
                        buffer[offset + stride + 0] = morph.x;
                        buffer[offset + stride + 1] = morph.y;
                        buffer[offset + stride + 2] = morph.z;
                        buffer[offset + stride + 3] = 0;
                    }
                    if (hasMorphNormals === true) {
                        morph.fromBufferAttribute(morphNormal, j);
                        buffer[offset + stride + 4] = morph.x;
                        buffer[offset + stride + 5] = morph.y;
                        buffer[offset + stride + 6] = morph.z;
                        buffer[offset + stride + 7] = 0;
                    }
                    if (hasMorphColors === true) {
                        morph.fromBufferAttribute(morphColor, j);
                        buffer[offset + stride + 8] = morph.x;
                        buffer[offset + stride + 9] = morph.y;
                        buffer[offset + stride + 10] = morph.z;
                        buffer[offset + stride + 11] = morphColor.itemSize === 4 ? morph.w : 1;
                    }
                }
            }
            entry = {
                count: morphTargetsCount,
                texture: texture,
                size: new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(width, height)
            };
            morphTextures.set(geometry, entry);
            function disposeTexture() {
                texture.dispose();
                morphTextures.delete(geometry);
                geometry.removeEventListener('dispose', disposeTexture);
            }
            geometry.addEventListener('dispose', disposeTexture);
        }
        //
        if (object.isInstancedMesh === true && object.morphTexture !== null) program.getUniforms().setValue(gl, 'morphTexture', object.morphTexture, textures);
        else {
            let morphInfluencesSum = 0;
            for(let i = 0; i < objectInfluences.length; i++)morphInfluencesSum += objectInfluences[i];
            const morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum;
            program.getUniforms().setValue(gl, 'morphTargetBaseInfluence', morphBaseInfluence);
            program.getUniforms().setValue(gl, 'morphTargetInfluences', objectInfluences);
        }
        program.getUniforms().setValue(gl, 'morphTargetsTexture', entry.texture, textures);
        program.getUniforms().setValue(gl, 'morphTargetsTextureSize', entry.size);
    }
    return {
        update: update
    };
}
function $3dd44ec8564e7230$var$WebGLObjects(gl, geometries, attributes, info) {
    let updateMap = new WeakMap();
    function update(object) {
        const frame = info.render.frame;
        const geometry = object.geometry;
        const buffergeometry = geometries.get(object, geometry);
        // Update once per frame
        if (updateMap.get(buffergeometry) !== frame) {
            geometries.update(buffergeometry);
            updateMap.set(buffergeometry, frame);
        }
        if (object.isInstancedMesh) {
            if (object.hasEventListener('dispose', onInstancedMeshDispose) === false) object.addEventListener('dispose', onInstancedMeshDispose);
            if (updateMap.get(object) !== frame) {
                attributes.update(object.instanceMatrix, gl.ARRAY_BUFFER);
                if (object.instanceColor !== null) attributes.update(object.instanceColor, gl.ARRAY_BUFFER);
                updateMap.set(object, frame);
            }
        }
        if (object.isSkinnedMesh) {
            const skeleton = object.skeleton;
            if (updateMap.get(skeleton) !== frame) {
                skeleton.update();
                updateMap.set(skeleton, frame);
            }
        }
        return buffergeometry;
    }
    function dispose() {
        updateMap = new WeakMap();
    }
    function onInstancedMeshDispose(event) {
        const instancedMesh = event.target;
        instancedMesh.removeEventListener('dispose', onInstancedMeshDispose);
        attributes.remove(instancedMesh.instanceMatrix);
        if (instancedMesh.instanceColor !== null) attributes.remove(instancedMesh.instanceColor);
    }
    return {
        update: update,
        dispose: dispose
    };
}
/**
 * Uniforms of a program.
 * Those form a tree structure with a special top-level container for the root,
 * which you get by calling 'new WebGLUniforms( gl, program )'.
 *
 *
 * Properties of inner nodes including the top-level container:
 *
 * .seq - array of nested uniforms
 * .map - nested uniforms by name
 *
 *
 * Methods of all nodes except the top-level container:
 *
 * .setValue( gl, value, [textures] )
 *
 * 		uploads a uniform value(s)
 *  	the 'textures' parameter is needed for sampler uniforms
 *
 *
 * Static methods of the top-level container (textures factorizations):
 *
 * .upload( gl, seq, values, textures )
 *
 * 		sets uniforms in 'seq' to 'values[id].value'
 *
 * .seqWithValue( seq, values ) : filteredSeq
 *
 * 		filters 'seq' entries with corresponding entry in values
 *
 *
 * Methods of the top-level container (textures factorizations):
 *
 * .setValue( gl, name, value, textures )
 *
 * 		sets uniform with  name 'name' to 'value'
 *
 * .setOptional( gl, obj, prop )
 *
 * 		like .set for an optional property of the object
 *
 */ const $3dd44ec8564e7230$var$emptyTexture = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$5431306cf43de24a)();
const $3dd44ec8564e7230$var$emptyShadowTexture = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$fc830aa069cc8c2f)(1, 1);
const $3dd44ec8564e7230$var$emptyArrayTexture = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$dfac6c8e811406a3)();
const $3dd44ec8564e7230$var$empty3dTexture = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$d7a3086320f856db)();
const $3dd44ec8564e7230$var$emptyCubeTexture = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$ee2e5a18258a4049)();
// --- Utilities ---
// Array Caches (provide typed arrays for temporary by size)
const $3dd44ec8564e7230$var$arrayCacheF32 = [];
const $3dd44ec8564e7230$var$arrayCacheI32 = [];
// Float32Array caches used for uploading Matrix uniforms
const $3dd44ec8564e7230$var$mat4array = new Float32Array(16);
const $3dd44ec8564e7230$var$mat3array = new Float32Array(9);
const $3dd44ec8564e7230$var$mat2array = new Float32Array(4);
// Flattening for arrays of vectors and matrices
function $3dd44ec8564e7230$var$flatten(array, nBlocks, blockSize) {
    const firstElem = array[0];
    if (firstElem <= 0 || firstElem > 0) return array;
    // unoptimized: ! isNaN( firstElem )
    // see http://jacksondunstan.com/articles/983
    const n = nBlocks * blockSize;
    let r = $3dd44ec8564e7230$var$arrayCacheF32[n];
    if (r === undefined) {
        r = new Float32Array(n);
        $3dd44ec8564e7230$var$arrayCacheF32[n] = r;
    }
    if (nBlocks !== 0) {
        firstElem.toArray(r, 0);
        for(let i = 1, offset = 0; i !== nBlocks; ++i){
            offset += blockSize;
            array[i].toArray(r, offset);
        }
    }
    return r;
}
function $3dd44ec8564e7230$var$arraysEqual(a, b) {
    if (a.length !== b.length) return false;
    for(let i = 0, l = a.length; i < l; i++){
        if (a[i] !== b[i]) return false;
    }
    return true;
}
function $3dd44ec8564e7230$var$copyArray(a, b) {
    for(let i = 0, l = b.length; i < l; i++)a[i] = b[i];
}
// Texture unit allocation
function $3dd44ec8564e7230$var$allocTexUnits(textures, n) {
    let r = $3dd44ec8564e7230$var$arrayCacheI32[n];
    if (r === undefined) {
        r = new Int32Array(n);
        $3dd44ec8564e7230$var$arrayCacheI32[n] = r;
    }
    for(let i = 0; i !== n; ++i)r[i] = textures.allocateTextureUnit();
    return r;
}
// --- Setters ---
// Note: Defining these methods externally, because they come in a bunch
// and this way their names minify.
// Single scalar
function $3dd44ec8564e7230$var$setValueV1f(gl, v) {
    const cache = this.cache;
    if (cache[0] === v) return;
    gl.uniform1f(this.addr, v);
    cache[0] = v;
}
// Single float vector (from flat array or THREE.VectorN)
function $3dd44ec8564e7230$var$setValueV2f(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y) {
            gl.uniform2f(this.addr, v.x, v.y);
            cache[0] = v.x;
            cache[1] = v.y;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform2fv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
function $3dd44ec8564e7230$var$setValueV3f(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) {
            gl.uniform3f(this.addr, v.x, v.y, v.z);
            cache[0] = v.x;
            cache[1] = v.y;
            cache[2] = v.z;
        }
    } else if (v.r !== undefined) {
        if (cache[0] !== v.r || cache[1] !== v.g || cache[2] !== v.b) {
            gl.uniform3f(this.addr, v.r, v.g, v.b);
            cache[0] = v.r;
            cache[1] = v.g;
            cache[2] = v.b;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform3fv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
function $3dd44ec8564e7230$var$setValueV4f(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) {
            gl.uniform4f(this.addr, v.x, v.y, v.z, v.w);
            cache[0] = v.x;
            cache[1] = v.y;
            cache[2] = v.z;
            cache[3] = v.w;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform4fv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
// Single matrix (from flat array or THREE.MatrixN)
function $3dd44ec8564e7230$var$setValueM2(gl, v) {
    const cache = this.cache;
    const elements = v.elements;
    if (elements === undefined) {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniformMatrix2fv(this.addr, false, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, elements)) return;
        $3dd44ec8564e7230$var$mat2array.set(elements);
        gl.uniformMatrix2fv(this.addr, false, $3dd44ec8564e7230$var$mat2array);
        $3dd44ec8564e7230$var$copyArray(cache, elements);
    }
}
function $3dd44ec8564e7230$var$setValueM3(gl, v) {
    const cache = this.cache;
    const elements = v.elements;
    if (elements === undefined) {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniformMatrix3fv(this.addr, false, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, elements)) return;
        $3dd44ec8564e7230$var$mat3array.set(elements);
        gl.uniformMatrix3fv(this.addr, false, $3dd44ec8564e7230$var$mat3array);
        $3dd44ec8564e7230$var$copyArray(cache, elements);
    }
}
function $3dd44ec8564e7230$var$setValueM4(gl, v) {
    const cache = this.cache;
    const elements = v.elements;
    if (elements === undefined) {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniformMatrix4fv(this.addr, false, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, elements)) return;
        $3dd44ec8564e7230$var$mat4array.set(elements);
        gl.uniformMatrix4fv(this.addr, false, $3dd44ec8564e7230$var$mat4array);
        $3dd44ec8564e7230$var$copyArray(cache, elements);
    }
}
// Single integer / boolean
function $3dd44ec8564e7230$var$setValueV1i(gl, v) {
    const cache = this.cache;
    if (cache[0] === v) return;
    gl.uniform1i(this.addr, v);
    cache[0] = v;
}
// Single integer / boolean vector (from flat array or THREE.VectorN)
function $3dd44ec8564e7230$var$setValueV2i(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y) {
            gl.uniform2i(this.addr, v.x, v.y);
            cache[0] = v.x;
            cache[1] = v.y;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform2iv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
function $3dd44ec8564e7230$var$setValueV3i(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) {
            gl.uniform3i(this.addr, v.x, v.y, v.z);
            cache[0] = v.x;
            cache[1] = v.y;
            cache[2] = v.z;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform3iv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
function $3dd44ec8564e7230$var$setValueV4i(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) {
            gl.uniform4i(this.addr, v.x, v.y, v.z, v.w);
            cache[0] = v.x;
            cache[1] = v.y;
            cache[2] = v.z;
            cache[3] = v.w;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform4iv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
// Single unsigned integer
function $3dd44ec8564e7230$var$setValueV1ui(gl, v) {
    const cache = this.cache;
    if (cache[0] === v) return;
    gl.uniform1ui(this.addr, v);
    cache[0] = v;
}
// Single unsigned integer vector (from flat array or THREE.VectorN)
function $3dd44ec8564e7230$var$setValueV2ui(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y) {
            gl.uniform2ui(this.addr, v.x, v.y);
            cache[0] = v.x;
            cache[1] = v.y;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform2uiv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
function $3dd44ec8564e7230$var$setValueV3ui(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z) {
            gl.uniform3ui(this.addr, v.x, v.y, v.z);
            cache[0] = v.x;
            cache[1] = v.y;
            cache[2] = v.z;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform3uiv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
function $3dd44ec8564e7230$var$setValueV4ui(gl, v) {
    const cache = this.cache;
    if (v.x !== undefined) {
        if (cache[0] !== v.x || cache[1] !== v.y || cache[2] !== v.z || cache[3] !== v.w) {
            gl.uniform4ui(this.addr, v.x, v.y, v.z, v.w);
            cache[0] = v.x;
            cache[1] = v.y;
            cache[2] = v.z;
            cache[3] = v.w;
        }
    } else {
        if ($3dd44ec8564e7230$var$arraysEqual(cache, v)) return;
        gl.uniform4uiv(this.addr, v);
        $3dd44ec8564e7230$var$copyArray(cache, v);
    }
}
// Single texture (2D / Cube)
function $3dd44ec8564e7230$var$setValueT1(gl, v, textures) {
    const cache = this.cache;
    const unit = textures.allocateTextureUnit();
    if (cache[0] !== unit) {
        gl.uniform1i(this.addr, unit);
        cache[0] = unit;
    }
    let emptyTexture2D;
    if (this.type === gl.SAMPLER_2D_SHADOW) {
        $3dd44ec8564e7230$var$emptyShadowTexture.compareFunction = (0, $d5b85d29c0b78636$export$64eea11eb407ddf1); // #28670
        emptyTexture2D = $3dd44ec8564e7230$var$emptyShadowTexture;
    } else emptyTexture2D = $3dd44ec8564e7230$var$emptyTexture;
    textures.setTexture2D(v || emptyTexture2D, unit);
}
function $3dd44ec8564e7230$var$setValueT3D1(gl, v, textures) {
    const cache = this.cache;
    const unit = textures.allocateTextureUnit();
    if (cache[0] !== unit) {
        gl.uniform1i(this.addr, unit);
        cache[0] = unit;
    }
    textures.setTexture3D(v || $3dd44ec8564e7230$var$empty3dTexture, unit);
}
function $3dd44ec8564e7230$var$setValueT6(gl, v, textures) {
    const cache = this.cache;
    const unit = textures.allocateTextureUnit();
    if (cache[0] !== unit) {
        gl.uniform1i(this.addr, unit);
        cache[0] = unit;
    }
    textures.setTextureCube(v || $3dd44ec8564e7230$var$emptyCubeTexture, unit);
}
function $3dd44ec8564e7230$var$setValueT2DArray1(gl, v, textures) {
    const cache = this.cache;
    const unit = textures.allocateTextureUnit();
    if (cache[0] !== unit) {
        gl.uniform1i(this.addr, unit);
        cache[0] = unit;
    }
    textures.setTexture2DArray(v || $3dd44ec8564e7230$var$emptyArrayTexture, unit);
}
// Helper to pick the right setter for the singular case
function $3dd44ec8564e7230$var$getSingularSetter(type) {
    switch(type){
        case 0x1406:
            return $3dd44ec8564e7230$var$setValueV1f; // FLOAT
        case 0x8b50:
            return $3dd44ec8564e7230$var$setValueV2f; // _VEC2
        case 0x8b51:
            return $3dd44ec8564e7230$var$setValueV3f; // _VEC3
        case 0x8b52:
            return $3dd44ec8564e7230$var$setValueV4f; // _VEC4
        case 0x8b5a:
            return $3dd44ec8564e7230$var$setValueM2; // _MAT2
        case 0x8b5b:
            return $3dd44ec8564e7230$var$setValueM3; // _MAT3
        case 0x8b5c:
            return $3dd44ec8564e7230$var$setValueM4; // _MAT4
        case 0x1404:
        case 0x8b56:
            return $3dd44ec8564e7230$var$setValueV1i; // INT, BOOL
        case 0x8b53:
        case 0x8b57:
            return $3dd44ec8564e7230$var$setValueV2i; // _VEC2
        case 0x8b54:
        case 0x8b58:
            return $3dd44ec8564e7230$var$setValueV3i; // _VEC3
        case 0x8b55:
        case 0x8b59:
            return $3dd44ec8564e7230$var$setValueV4i; // _VEC4
        case 0x1405:
            return $3dd44ec8564e7230$var$setValueV1ui; // UINT
        case 0x8dc6:
            return $3dd44ec8564e7230$var$setValueV2ui; // _VEC2
        case 0x8dc7:
            return $3dd44ec8564e7230$var$setValueV3ui; // _VEC3
        case 0x8dc8:
            return $3dd44ec8564e7230$var$setValueV4ui; // _VEC4
        case 0x8b5e:
        case 0x8d66:
        case 0x8dca:
        case 0x8dd2:
        case 0x8b62:
            return $3dd44ec8564e7230$var$setValueT1;
        case 0x8b5f:
        case 0x8dcb:
        case 0x8dd3:
            return $3dd44ec8564e7230$var$setValueT3D1;
        case 0x8b60:
        case 0x8dcc:
        case 0x8dd4:
        case 0x8dc5:
            return $3dd44ec8564e7230$var$setValueT6;
        case 0x8dc1:
        case 0x8dcf:
        case 0x8dd7:
        case 0x8dc4:
            return $3dd44ec8564e7230$var$setValueT2DArray1;
    }
}
// Array of scalars
function $3dd44ec8564e7230$var$setValueV1fArray(gl, v) {
    gl.uniform1fv(this.addr, v);
}
// Array of vectors (from flat array or array of THREE.VectorN)
function $3dd44ec8564e7230$var$setValueV2fArray(gl, v) {
    const data = $3dd44ec8564e7230$var$flatten(v, this.size, 2);
    gl.uniform2fv(this.addr, data);
}
function $3dd44ec8564e7230$var$setValueV3fArray(gl, v) {
    const data = $3dd44ec8564e7230$var$flatten(v, this.size, 3);
    gl.uniform3fv(this.addr, data);
}
function $3dd44ec8564e7230$var$setValueV4fArray(gl, v) {
    const data = $3dd44ec8564e7230$var$flatten(v, this.size, 4);
    gl.uniform4fv(this.addr, data);
}
// Array of matrices (from flat array or array of THREE.MatrixN)
function $3dd44ec8564e7230$var$setValueM2Array(gl, v) {
    const data = $3dd44ec8564e7230$var$flatten(v, this.size, 4);
    gl.uniformMatrix2fv(this.addr, false, data);
}
function $3dd44ec8564e7230$var$setValueM3Array(gl, v) {
    const data = $3dd44ec8564e7230$var$flatten(v, this.size, 9);
    gl.uniformMatrix3fv(this.addr, false, data);
}
function $3dd44ec8564e7230$var$setValueM4Array(gl, v) {
    const data = $3dd44ec8564e7230$var$flatten(v, this.size, 16);
    gl.uniformMatrix4fv(this.addr, false, data);
}
// Array of integer / boolean
function $3dd44ec8564e7230$var$setValueV1iArray(gl, v) {
    gl.uniform1iv(this.addr, v);
}
// Array of integer / boolean vectors (from flat array)
function $3dd44ec8564e7230$var$setValueV2iArray(gl, v) {
    gl.uniform2iv(this.addr, v);
}
function $3dd44ec8564e7230$var$setValueV3iArray(gl, v) {
    gl.uniform3iv(this.addr, v);
}
function $3dd44ec8564e7230$var$setValueV4iArray(gl, v) {
    gl.uniform4iv(this.addr, v);
}
// Array of unsigned integer
function $3dd44ec8564e7230$var$setValueV1uiArray(gl, v) {
    gl.uniform1uiv(this.addr, v);
}
// Array of unsigned integer vectors (from flat array)
function $3dd44ec8564e7230$var$setValueV2uiArray(gl, v) {
    gl.uniform2uiv(this.addr, v);
}
function $3dd44ec8564e7230$var$setValueV3uiArray(gl, v) {
    gl.uniform3uiv(this.addr, v);
}
function $3dd44ec8564e7230$var$setValueV4uiArray(gl, v) {
    gl.uniform4uiv(this.addr, v);
}
// Array of textures (2D / 3D / Cube / 2DArray)
function $3dd44ec8564e7230$var$setValueT1Array(gl, v, textures) {
    const cache = this.cache;
    const n = v.length;
    const units = $3dd44ec8564e7230$var$allocTexUnits(textures, n);
    if (!$3dd44ec8564e7230$var$arraysEqual(cache, units)) {
        gl.uniform1iv(this.addr, units);
        $3dd44ec8564e7230$var$copyArray(cache, units);
    }
    for(let i = 0; i !== n; ++i)textures.setTexture2D(v[i] || $3dd44ec8564e7230$var$emptyTexture, units[i]);
}
function $3dd44ec8564e7230$var$setValueT3DArray(gl, v, textures) {
    const cache = this.cache;
    const n = v.length;
    const units = $3dd44ec8564e7230$var$allocTexUnits(textures, n);
    if (!$3dd44ec8564e7230$var$arraysEqual(cache, units)) {
        gl.uniform1iv(this.addr, units);
        $3dd44ec8564e7230$var$copyArray(cache, units);
    }
    for(let i = 0; i !== n; ++i)textures.setTexture3D(v[i] || $3dd44ec8564e7230$var$empty3dTexture, units[i]);
}
function $3dd44ec8564e7230$var$setValueT6Array(gl, v, textures) {
    const cache = this.cache;
    const n = v.length;
    const units = $3dd44ec8564e7230$var$allocTexUnits(textures, n);
    if (!$3dd44ec8564e7230$var$arraysEqual(cache, units)) {
        gl.uniform1iv(this.addr, units);
        $3dd44ec8564e7230$var$copyArray(cache, units);
    }
    for(let i = 0; i !== n; ++i)textures.setTextureCube(v[i] || $3dd44ec8564e7230$var$emptyCubeTexture, units[i]);
}
function $3dd44ec8564e7230$var$setValueT2DArrayArray(gl, v, textures) {
    const cache = this.cache;
    const n = v.length;
    const units = $3dd44ec8564e7230$var$allocTexUnits(textures, n);
    if (!$3dd44ec8564e7230$var$arraysEqual(cache, units)) {
        gl.uniform1iv(this.addr, units);
        $3dd44ec8564e7230$var$copyArray(cache, units);
    }
    for(let i = 0; i !== n; ++i)textures.setTexture2DArray(v[i] || $3dd44ec8564e7230$var$emptyArrayTexture, units[i]);
}
// Helper to pick the right setter for a pure (bottom-level) array
function $3dd44ec8564e7230$var$getPureArraySetter(type) {
    switch(type){
        case 0x1406:
            return $3dd44ec8564e7230$var$setValueV1fArray; // FLOAT
        case 0x8b50:
            return $3dd44ec8564e7230$var$setValueV2fArray; // _VEC2
        case 0x8b51:
            return $3dd44ec8564e7230$var$setValueV3fArray; // _VEC3
        case 0x8b52:
            return $3dd44ec8564e7230$var$setValueV4fArray; // _VEC4
        case 0x8b5a:
            return $3dd44ec8564e7230$var$setValueM2Array; // _MAT2
        case 0x8b5b:
            return $3dd44ec8564e7230$var$setValueM3Array; // _MAT3
        case 0x8b5c:
            return $3dd44ec8564e7230$var$setValueM4Array; // _MAT4
        case 0x1404:
        case 0x8b56:
            return $3dd44ec8564e7230$var$setValueV1iArray; // INT, BOOL
        case 0x8b53:
        case 0x8b57:
            return $3dd44ec8564e7230$var$setValueV2iArray; // _VEC2
        case 0x8b54:
        case 0x8b58:
            return $3dd44ec8564e7230$var$setValueV3iArray; // _VEC3
        case 0x8b55:
        case 0x8b59:
            return $3dd44ec8564e7230$var$setValueV4iArray; // _VEC4
        case 0x1405:
            return $3dd44ec8564e7230$var$setValueV1uiArray; // UINT
        case 0x8dc6:
            return $3dd44ec8564e7230$var$setValueV2uiArray; // _VEC2
        case 0x8dc7:
            return $3dd44ec8564e7230$var$setValueV3uiArray; // _VEC3
        case 0x8dc8:
            return $3dd44ec8564e7230$var$setValueV4uiArray; // _VEC4
        case 0x8b5e:
        case 0x8d66:
        case 0x8dca:
        case 0x8dd2:
        case 0x8b62:
            return $3dd44ec8564e7230$var$setValueT1Array;
        case 0x8b5f:
        case 0x8dcb:
        case 0x8dd3:
            return $3dd44ec8564e7230$var$setValueT3DArray;
        case 0x8b60:
        case 0x8dcc:
        case 0x8dd4:
        case 0x8dc5:
            return $3dd44ec8564e7230$var$setValueT6Array;
        case 0x8dc1:
        case 0x8dcf:
        case 0x8dd7:
        case 0x8dc4:
            return $3dd44ec8564e7230$var$setValueT2DArrayArray;
    }
}
// --- Uniform Classes ---
class $3dd44ec8564e7230$var$SingleUniform {
    constructor(id, activeInfo, addr){
        this.id = id;
        this.addr = addr;
        this.cache = [];
        this.type = activeInfo.type;
        this.setValue = $3dd44ec8564e7230$var$getSingularSetter(activeInfo.type);
    // this.path = activeInfo.name; // DEBUG
    }
}
class $3dd44ec8564e7230$var$PureArrayUniform {
    constructor(id, activeInfo, addr){
        this.id = id;
        this.addr = addr;
        this.cache = [];
        this.type = activeInfo.type;
        this.size = activeInfo.size;
        this.setValue = $3dd44ec8564e7230$var$getPureArraySetter(activeInfo.type);
    // this.path = activeInfo.name; // DEBUG
    }
}
class $3dd44ec8564e7230$var$StructuredUniform {
    constructor(id){
        this.id = id;
        this.seq = [];
        this.map = {};
    }
    setValue(gl, value, textures) {
        const seq = this.seq;
        for(let i = 0, n = seq.length; i !== n; ++i){
            const u = seq[i];
            u.setValue(gl, value[u.id], textures);
        }
    }
}
// --- Top-level ---
// Parser - builds up the property tree from the path strings
const $3dd44ec8564e7230$var$RePathPart = /(\w+)(\])?(\[|\.)?/g;
// extracts
// 	- the identifier (member name or array index)
//  - followed by an optional right bracket (found when array index)
//  - followed by an optional left bracket or dot (type of subscript)
//
// Note: These portions can be read in a non-overlapping fashion and
// allow straightforward parsing of the hierarchy that WebGL encodes
// in the uniform names.
function $3dd44ec8564e7230$var$addUniform(container, uniformObject) {
    container.seq.push(uniformObject);
    container.map[uniformObject.id] = uniformObject;
}
function $3dd44ec8564e7230$var$parseUniform(activeInfo, addr, container) {
    const path = activeInfo.name, pathLength = path.length;
    // reset RegExp object, because of the early exit of a previous run
    $3dd44ec8564e7230$var$RePathPart.lastIndex = 0;
    while(true){
        const match = $3dd44ec8564e7230$var$RePathPart.exec(path), matchEnd = $3dd44ec8564e7230$var$RePathPart.lastIndex;
        let id = match[1];
        const idIsIndex = match[2] === ']', subscript = match[3];
        if (idIsIndex) id = id | 0; // convert to integer
        if (subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength) {
            // bare name or "pure" bottom-level array "[0]" suffix
            $3dd44ec8564e7230$var$addUniform(container, subscript === undefined ? new $3dd44ec8564e7230$var$SingleUniform(id, activeInfo, addr) : new $3dd44ec8564e7230$var$PureArrayUniform(id, activeInfo, addr));
            break;
        } else {
            // step into inner node / create it in case it doesn't exist
            const map = container.map;
            let next = map[id];
            if (next === undefined) {
                next = new $3dd44ec8564e7230$var$StructuredUniform(id);
                $3dd44ec8564e7230$var$addUniform(container, next);
            }
            container = next;
        }
    }
}
// Root Container
class $3dd44ec8564e7230$var$WebGLUniforms {
    constructor(gl, program){
        this.seq = [];
        this.map = {};
        const n = gl.getProgramParameter(program, gl.ACTIVE_UNIFORMS);
        for(let i = 0; i < n; ++i){
            const info = gl.getActiveUniform(program, i), addr = gl.getUniformLocation(program, info.name);
            $3dd44ec8564e7230$var$parseUniform(info, addr, this);
        }
    }
    setValue(gl, name, value, textures) {
        const u = this.map[name];
        if (u !== undefined) u.setValue(gl, value, textures);
    }
    setOptional(gl, object, name) {
        const v = object[name];
        if (v !== undefined) this.setValue(gl, name, v);
    }
    static upload(gl, seq, values, textures) {
        for(let i = 0, n = seq.length; i !== n; ++i){
            const u = seq[i], v = values[u.id];
            if (v.needsUpdate !== false) // note: always updating when .needsUpdate is undefined
            u.setValue(gl, v.value, textures);
        }
    }
    static seqWithValue(seq, values) {
        const r = [];
        for(let i = 0, n = seq.length; i !== n; ++i){
            const u = seq[i];
            if (u.id in values) r.push(u);
        }
        return r;
    }
}
function $3dd44ec8564e7230$var$WebGLShader(gl, type, string) {
    const shader = gl.createShader(type);
    gl.shaderSource(shader, string);
    gl.compileShader(shader);
    return shader;
}
// From https://www.khronos.org/registry/webgl/extensions/KHR_parallel_shader_compile/
const $3dd44ec8564e7230$var$COMPLETION_STATUS_KHR = 0x91B1;
let $3dd44ec8564e7230$var$programIdCount = 0;
function $3dd44ec8564e7230$var$handleSource(string, errorLine) {
    const lines = string.split('\n');
    const lines2 = [];
    const from = Math.max(errorLine - 6, 0);
    const to = Math.min(errorLine + 6, lines.length);
    for(let i = from; i < to; i++){
        const line = i + 1;
        lines2.push(`${line === errorLine ? '>' : ' '} ${line}: ${lines[i]}`);
    }
    return lines2.join('\n');
}
const $3dd44ec8564e7230$var$_m0 = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$8ff26dafa08918)();
function $3dd44ec8564e7230$var$getEncodingComponents(colorSpace) {
    (0, $d5b85d29c0b78636$export$5e6fd513f44698c)._getMatrix($3dd44ec8564e7230$var$_m0, (0, $d5b85d29c0b78636$export$5e6fd513f44698c).workingColorSpace, colorSpace);
    const encodingMatrix = `mat3( ${$3dd44ec8564e7230$var$_m0.elements.map((v)=>v.toFixed(4))} )`;
    switch((0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(colorSpace)){
        case 0, $d5b85d29c0b78636$export$f197347d588c1b4a:
            return [
                encodingMatrix,
                'LinearTransferOETF'
            ];
        case 0, $d5b85d29c0b78636$export$8d0a61916cc26abb:
            return [
                encodingMatrix,
                'sRGBTransferOETF'
            ];
        default:
            console.warn('THREE.WebGLProgram: Unsupported color space: ', colorSpace);
            return [
                encodingMatrix,
                'LinearTransferOETF'
            ];
    }
}
function $3dd44ec8564e7230$var$getShaderErrors(gl, shader, type) {
    const status = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
    const errors = gl.getShaderInfoLog(shader).trim();
    if (status && errors === '') return '';
    const errorMatches = /ERROR: 0:(\d+)/.exec(errors);
    if (errorMatches) {
        // --enable-privileged-webgl-extension
        // console.log( '**' + type + '**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );
        const errorLine = parseInt(errorMatches[1]);
        return type.toUpperCase() + '\n\n' + errors + '\n\n' + $3dd44ec8564e7230$var$handleSource(gl.getShaderSource(shader), errorLine);
    } else return errors;
}
function $3dd44ec8564e7230$var$getTexelEncodingFunction(functionName, colorSpace) {
    const components = $3dd44ec8564e7230$var$getEncodingComponents(colorSpace);
    return [
        `vec4 ${functionName}( vec4 value ) {`,
        `	return ${components[1]}( vec4( value.rgb * ${components[0]}, value.a ) );`,
        '}'
    ].join('\n');
}
function $3dd44ec8564e7230$var$getToneMappingFunction(functionName, toneMapping) {
    let toneMappingName;
    switch(toneMapping){
        case 0, $d5b85d29c0b78636$export$98f52c2a46c598ca:
            toneMappingName = 'Linear';
            break;
        case 0, $d5b85d29c0b78636$export$74b25e54b3bcd548:
            toneMappingName = 'Reinhard';
            break;
        case 0, $d5b85d29c0b78636$export$932b3dd283d4a366:
            toneMappingName = 'Cineon';
            break;
        case 0, $d5b85d29c0b78636$export$a0d98fe6d7e4af64:
            toneMappingName = 'ACESFilmic';
            break;
        case 0, $d5b85d29c0b78636$export$212d53a513a325b2:
            toneMappingName = 'AgX';
            break;
        case 0, $d5b85d29c0b78636$export$f2863e1668a8e317:
            toneMappingName = 'Neutral';
            break;
        case 0, $d5b85d29c0b78636$export$2c7b09c1e9abfb5e:
            toneMappingName = 'Custom';
            break;
        default:
            console.warn('THREE.WebGLProgram: Unsupported toneMapping:', toneMapping);
            toneMappingName = 'Linear';
    }
    return 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';
}
const $3dd44ec8564e7230$var$_v0 = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
function $3dd44ec8564e7230$var$getLuminanceFunction() {
    (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getLuminanceCoefficients($3dd44ec8564e7230$var$_v0);
    const r = $3dd44ec8564e7230$var$_v0.x.toFixed(4);
    const g = $3dd44ec8564e7230$var$_v0.y.toFixed(4);
    const b = $3dd44ec8564e7230$var$_v0.z.toFixed(4);
    return [
        'float luminance( const in vec3 rgb ) {',
        `	const vec3 weights = vec3( ${r}, ${g}, ${b} );`,
        '	return dot( weights, rgb );',
        '}'
    ].join('\n');
}
function $3dd44ec8564e7230$var$generateVertexExtensions(parameters) {
    const chunks = [
        parameters.extensionClipCullDistance ? '#extension GL_ANGLE_clip_cull_distance : require' : '',
        parameters.extensionMultiDraw ? '#extension GL_ANGLE_multi_draw : require' : ''
    ];
    return chunks.filter($3dd44ec8564e7230$var$filterEmptyLine).join('\n');
}
function $3dd44ec8564e7230$var$generateDefines(defines) {
    const chunks = [];
    for(const name in defines){
        const value = defines[name];
        if (value === false) continue;
        chunks.push('#define ' + name + ' ' + value);
    }
    return chunks.join('\n');
}
function $3dd44ec8564e7230$var$fetchAttributeLocations(gl, program) {
    const attributes = {};
    const n = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
    for(let i = 0; i < n; i++){
        const info = gl.getActiveAttrib(program, i);
        const name = info.name;
        let locationSize = 1;
        if (info.type === gl.FLOAT_MAT2) locationSize = 2;
        if (info.type === gl.FLOAT_MAT3) locationSize = 3;
        if (info.type === gl.FLOAT_MAT4) locationSize = 4;
        // console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );
        attributes[name] = {
            type: info.type,
            location: gl.getAttribLocation(program, name),
            locationSize: locationSize
        };
    }
    return attributes;
}
function $3dd44ec8564e7230$var$filterEmptyLine(string) {
    return string !== '';
}
function $3dd44ec8564e7230$var$replaceLightNums(string, parameters) {
    const numSpotLightCoords = parameters.numSpotLightShadows + parameters.numSpotLightMaps - parameters.numSpotLightShadowsWithMaps;
    return string.replace(/NUM_DIR_LIGHTS/g, parameters.numDirLights).replace(/NUM_SPOT_LIGHTS/g, parameters.numSpotLights).replace(/NUM_SPOT_LIGHT_MAPS/g, parameters.numSpotLightMaps).replace(/NUM_SPOT_LIGHT_COORDS/g, numSpotLightCoords).replace(/NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights).replace(/NUM_POINT_LIGHTS/g, parameters.numPointLights).replace(/NUM_HEMI_LIGHTS/g, parameters.numHemiLights).replace(/NUM_DIR_LIGHT_SHADOWS/g, parameters.numDirLightShadows).replace(/NUM_SPOT_LIGHT_SHADOWS_WITH_MAPS/g, parameters.numSpotLightShadowsWithMaps).replace(/NUM_SPOT_LIGHT_SHADOWS/g, parameters.numSpotLightShadows).replace(/NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows);
}
function $3dd44ec8564e7230$var$replaceClippingPlaneNums(string, parameters) {
    return string.replace(/NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes).replace(/UNION_CLIPPING_PLANES/g, parameters.numClippingPlanes - parameters.numClipIntersection);
}
// Resolve Includes
const $3dd44ec8564e7230$var$includePattern = /^[ \t]*#include +<([\w\d./]+)>/gm;
function $3dd44ec8564e7230$var$resolveIncludes(string) {
    return string.replace($3dd44ec8564e7230$var$includePattern, $3dd44ec8564e7230$var$includeReplacer);
}
const $3dd44ec8564e7230$var$shaderChunkMap = new Map();
function $3dd44ec8564e7230$var$includeReplacer(match, include) {
    let string = $3dd44ec8564e7230$export$955f9f2e84c43c8b[include];
    if (string === undefined) {
        const newInclude = $3dd44ec8564e7230$var$shaderChunkMap.get(include);
        if (newInclude !== undefined) {
            string = $3dd44ec8564e7230$export$955f9f2e84c43c8b[newInclude];
            console.warn('THREE.WebGLRenderer: Shader chunk "%s" has been deprecated. Use "%s" instead.', include, newInclude);
        } else throw new Error('Can not resolve #include <' + include + '>');
    }
    return $3dd44ec8564e7230$var$resolveIncludes(string);
}
// Unroll Loops
const $3dd44ec8564e7230$var$unrollLoopPattern = /#pragma unroll_loop_start\s+for\s*\(\s*int\s+i\s*=\s*(\d+)\s*;\s*i\s*<\s*(\d+)\s*;\s*i\s*\+\+\s*\)\s*{([\s\S]+?)}\s+#pragma unroll_loop_end/g;
function $3dd44ec8564e7230$var$unrollLoops(string) {
    return string.replace($3dd44ec8564e7230$var$unrollLoopPattern, $3dd44ec8564e7230$var$loopReplacer);
}
function $3dd44ec8564e7230$var$loopReplacer(match, start, end, snippet) {
    let string = '';
    for(let i = parseInt(start); i < parseInt(end); i++)string += snippet.replace(/\[\s*i\s*\]/g, '[ ' + i + ' ]').replace(/UNROLLED_LOOP_INDEX/g, i);
    return string;
}
//
function $3dd44ec8564e7230$var$generatePrecision(parameters) {
    let precisionstring = `precision ${parameters.precision} float;
	precision ${parameters.precision} int;
	precision ${parameters.precision} sampler2D;
	precision ${parameters.precision} samplerCube;
	precision ${parameters.precision} sampler3D;
	precision ${parameters.precision} sampler2DArray;
	precision ${parameters.precision} sampler2DShadow;
	precision ${parameters.precision} samplerCubeShadow;
	precision ${parameters.precision} sampler2DArrayShadow;
	precision ${parameters.precision} isampler2D;
	precision ${parameters.precision} isampler3D;
	precision ${parameters.precision} isamplerCube;
	precision ${parameters.precision} isampler2DArray;
	precision ${parameters.precision} usampler2D;
	precision ${parameters.precision} usampler3D;
	precision ${parameters.precision} usamplerCube;
	precision ${parameters.precision} usampler2DArray;
	`;
    if (parameters.precision === 'highp') precisionstring += '\n#define HIGH_PRECISION';
    else if (parameters.precision === 'mediump') precisionstring += '\n#define MEDIUM_PRECISION';
    else if (parameters.precision === 'lowp') precisionstring += '\n#define LOW_PRECISION';
    return precisionstring;
}
function $3dd44ec8564e7230$var$generateShadowMapTypeDefine(parameters) {
    let shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';
    if (parameters.shadowMapType === (0, $d5b85d29c0b78636$export$5813f879eee7cd88)) shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';
    else if (parameters.shadowMapType === (0, $d5b85d29c0b78636$export$a47c4b43a1be34f0)) shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';
    else if (parameters.shadowMapType === (0, $d5b85d29c0b78636$export$896ae1ade6c829c4)) shadowMapTypeDefine = 'SHADOWMAP_TYPE_VSM';
    return shadowMapTypeDefine;
}
function $3dd44ec8564e7230$var$generateEnvMapTypeDefine(parameters) {
    let envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
    if (parameters.envMap) switch(parameters.envMapMode){
        case 0, $d5b85d29c0b78636$export$8759762a6477f2c4:
        case 0, $d5b85d29c0b78636$export$dc59f8aed047f61d:
            envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
            break;
        case 0, $d5b85d29c0b78636$export$dbf3e70ff37af79:
            envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
            break;
    }
    return envMapTypeDefine;
}
function $3dd44ec8564e7230$var$generateEnvMapModeDefine(parameters) {
    let envMapModeDefine = 'ENVMAP_MODE_REFLECTION';
    if (parameters.envMap) switch(parameters.envMapMode){
        case 0, $d5b85d29c0b78636$export$dc59f8aed047f61d:
            envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
            break;
    }
    return envMapModeDefine;
}
function $3dd44ec8564e7230$var$generateEnvMapBlendingDefine(parameters) {
    let envMapBlendingDefine = 'ENVMAP_BLENDING_NONE';
    if (parameters.envMap) switch(parameters.combine){
        case 0, $d5b85d29c0b78636$export$e50ac29801f1774d:
            envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
            break;
        case 0, $d5b85d29c0b78636$export$9f9d94f963c85479:
            envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
            break;
        case 0, $d5b85d29c0b78636$export$e641dc52bc3494aa:
            envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
            break;
    }
    return envMapBlendingDefine;
}
function $3dd44ec8564e7230$var$generateCubeUVSize(parameters) {
    const imageHeight = parameters.envMapCubeUVHeight;
    if (imageHeight === null) return null;
    const maxMip = Math.log2(imageHeight) - 2;
    const texelHeight = 1.0 / imageHeight;
    const texelWidth = 1.0 / (3 * Math.max(Math.pow(2, maxMip), 112));
    return {
        texelWidth: texelWidth,
        texelHeight: texelHeight,
        maxMip: maxMip
    };
}
function $3dd44ec8564e7230$var$WebGLProgram(renderer, cacheKey, parameters, bindingStates) {
    // TODO Send this event to Three.js DevTools
    // console.log( 'WebGLProgram', cacheKey );
    const gl = renderer.getContext();
    const defines = parameters.defines;
    let vertexShader = parameters.vertexShader;
    let fragmentShader = parameters.fragmentShader;
    const shadowMapTypeDefine = $3dd44ec8564e7230$var$generateShadowMapTypeDefine(parameters);
    const envMapTypeDefine = $3dd44ec8564e7230$var$generateEnvMapTypeDefine(parameters);
    const envMapModeDefine = $3dd44ec8564e7230$var$generateEnvMapModeDefine(parameters);
    const envMapBlendingDefine = $3dd44ec8564e7230$var$generateEnvMapBlendingDefine(parameters);
    const envMapCubeUVSize = $3dd44ec8564e7230$var$generateCubeUVSize(parameters);
    const customVertexExtensions = $3dd44ec8564e7230$var$generateVertexExtensions(parameters);
    const customDefines = $3dd44ec8564e7230$var$generateDefines(defines);
    const program = gl.createProgram();
    let prefixVertex, prefixFragment;
    let versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\n' : '';
    if (parameters.isRawShaderMaterial) {
        prefixVertex = [
            '#define SHADER_TYPE ' + parameters.shaderType,
            '#define SHADER_NAME ' + parameters.shaderName,
            customDefines
        ].filter($3dd44ec8564e7230$var$filterEmptyLine).join('\n');
        if (prefixVertex.length > 0) prefixVertex += '\n';
        prefixFragment = [
            '#define SHADER_TYPE ' + parameters.shaderType,
            '#define SHADER_NAME ' + parameters.shaderName,
            customDefines
        ].filter($3dd44ec8564e7230$var$filterEmptyLine).join('\n');
        if (prefixFragment.length > 0) prefixFragment += '\n';
    } else {
        prefixVertex = [
            $3dd44ec8564e7230$var$generatePrecision(parameters),
            '#define SHADER_TYPE ' + parameters.shaderType,
            '#define SHADER_NAME ' + parameters.shaderName,
            customDefines,
            parameters.extensionClipCullDistance ? '#define USE_CLIP_DISTANCE' : '',
            parameters.batching ? '#define USE_BATCHING' : '',
            parameters.batchingColor ? '#define USE_BATCHING_COLOR' : '',
            parameters.instancing ? '#define USE_INSTANCING' : '',
            parameters.instancingColor ? '#define USE_INSTANCING_COLOR' : '',
            parameters.instancingMorph ? '#define USE_INSTANCING_MORPH' : '',
            parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
            parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
            parameters.map ? '#define USE_MAP' : '',
            parameters.envMap ? '#define USE_ENVMAP' : '',
            parameters.envMap ? '#define ' + envMapModeDefine : '',
            parameters.lightMap ? '#define USE_LIGHTMAP' : '',
            parameters.aoMap ? '#define USE_AOMAP' : '',
            parameters.bumpMap ? '#define USE_BUMPMAP' : '',
            parameters.normalMap ? '#define USE_NORMALMAP' : '',
            parameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',
            parameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',
            parameters.displacementMap ? '#define USE_DISPLACEMENTMAP' : '',
            parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
            parameters.anisotropy ? '#define USE_ANISOTROPY' : '',
            parameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',
            parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
            parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
            parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
            parameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',
            parameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',
            parameters.specularMap ? '#define USE_SPECULARMAP' : '',
            parameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',
            parameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',
            parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
            parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
            parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
            parameters.alphaHash ? '#define USE_ALPHAHASH' : '',
            parameters.transmission ? '#define USE_TRANSMISSION' : '',
            parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
            parameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',
            parameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',
            parameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',
            //
            parameters.mapUv ? '#define MAP_UV ' + parameters.mapUv : '',
            parameters.alphaMapUv ? '#define ALPHAMAP_UV ' + parameters.alphaMapUv : '',
            parameters.lightMapUv ? '#define LIGHTMAP_UV ' + parameters.lightMapUv : '',
            parameters.aoMapUv ? '#define AOMAP_UV ' + parameters.aoMapUv : '',
            parameters.emissiveMapUv ? '#define EMISSIVEMAP_UV ' + parameters.emissiveMapUv : '',
            parameters.bumpMapUv ? '#define BUMPMAP_UV ' + parameters.bumpMapUv : '',
            parameters.normalMapUv ? '#define NORMALMAP_UV ' + parameters.normalMapUv : '',
            parameters.displacementMapUv ? '#define DISPLACEMENTMAP_UV ' + parameters.displacementMapUv : '',
            parameters.metalnessMapUv ? '#define METALNESSMAP_UV ' + parameters.metalnessMapUv : '',
            parameters.roughnessMapUv ? '#define ROUGHNESSMAP_UV ' + parameters.roughnessMapUv : '',
            parameters.anisotropyMapUv ? '#define ANISOTROPYMAP_UV ' + parameters.anisotropyMapUv : '',
            parameters.clearcoatMapUv ? '#define CLEARCOATMAP_UV ' + parameters.clearcoatMapUv : '',
            parameters.clearcoatNormalMapUv ? '#define CLEARCOAT_NORMALMAP_UV ' + parameters.clearcoatNormalMapUv : '',
            parameters.clearcoatRoughnessMapUv ? '#define CLEARCOAT_ROUGHNESSMAP_UV ' + parameters.clearcoatRoughnessMapUv : '',
            parameters.iridescenceMapUv ? '#define IRIDESCENCEMAP_UV ' + parameters.iridescenceMapUv : '',
            parameters.iridescenceThicknessMapUv ? '#define IRIDESCENCE_THICKNESSMAP_UV ' + parameters.iridescenceThicknessMapUv : '',
            parameters.sheenColorMapUv ? '#define SHEEN_COLORMAP_UV ' + parameters.sheenColorMapUv : '',
            parameters.sheenRoughnessMapUv ? '#define SHEEN_ROUGHNESSMAP_UV ' + parameters.sheenRoughnessMapUv : '',
            parameters.specularMapUv ? '#define SPECULARMAP_UV ' + parameters.specularMapUv : '',
            parameters.specularColorMapUv ? '#define SPECULAR_COLORMAP_UV ' + parameters.specularColorMapUv : '',
            parameters.specularIntensityMapUv ? '#define SPECULAR_INTENSITYMAP_UV ' + parameters.specularIntensityMapUv : '',
            parameters.transmissionMapUv ? '#define TRANSMISSIONMAP_UV ' + parameters.transmissionMapUv : '',
            parameters.thicknessMapUv ? '#define THICKNESSMAP_UV ' + parameters.thicknessMapUv : '',
            //
            parameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',
            parameters.vertexColors ? '#define USE_COLOR' : '',
            parameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',
            parameters.vertexUv1s ? '#define USE_UV1' : '',
            parameters.vertexUv2s ? '#define USE_UV2' : '',
            parameters.vertexUv3s ? '#define USE_UV3' : '',
            parameters.pointsUvs ? '#define USE_POINTS_UV' : '',
            parameters.flatShading ? '#define FLAT_SHADED' : '',
            parameters.skinning ? '#define USE_SKINNING' : '',
            parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
            parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',
            parameters.morphColors ? '#define USE_MORPHCOLORS' : '',
            parameters.morphTargetsCount > 0 ? '#define MORPHTARGETS_TEXTURE_STRIDE ' + parameters.morphTextureStride : '',
            parameters.morphTargetsCount > 0 ? '#define MORPHTARGETS_COUNT ' + parameters.morphTargetsCount : '',
            parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
            parameters.flipSided ? '#define FLIP_SIDED' : '',
            parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
            parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
            parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',
            parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
            parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
            parameters.reverseDepthBuffer ? '#define USE_REVERSEDEPTHBUF' : '',
            'uniform mat4 modelMatrix;',
            'uniform mat4 modelViewMatrix;',
            'uniform mat4 projectionMatrix;',
            'uniform mat4 viewMatrix;',
            'uniform mat3 normalMatrix;',
            'uniform vec3 cameraPosition;',
            'uniform bool isOrthographic;',
            '#ifdef USE_INSTANCING',
            '	attribute mat4 instanceMatrix;',
            '#endif',
            '#ifdef USE_INSTANCING_COLOR',
            '	attribute vec3 instanceColor;',
            '#endif',
            '#ifdef USE_INSTANCING_MORPH',
            '	uniform sampler2D morphTexture;',
            '#endif',
            'attribute vec3 position;',
            'attribute vec3 normal;',
            'attribute vec2 uv;',
            '#ifdef USE_UV1',
            '	attribute vec2 uv1;',
            '#endif',
            '#ifdef USE_UV2',
            '	attribute vec2 uv2;',
            '#endif',
            '#ifdef USE_UV3',
            '	attribute vec2 uv3;',
            '#endif',
            '#ifdef USE_TANGENT',
            '	attribute vec4 tangent;',
            '#endif',
            '#if defined( USE_COLOR_ALPHA )',
            '	attribute vec4 color;',
            '#elif defined( USE_COLOR )',
            '	attribute vec3 color;',
            '#endif',
            '#ifdef USE_SKINNING',
            '	attribute vec4 skinIndex;',
            '	attribute vec4 skinWeight;',
            '#endif',
            '\n'
        ].filter($3dd44ec8564e7230$var$filterEmptyLine).join('\n');
        prefixFragment = [
            $3dd44ec8564e7230$var$generatePrecision(parameters),
            '#define SHADER_TYPE ' + parameters.shaderType,
            '#define SHADER_NAME ' + parameters.shaderName,
            customDefines,
            parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
            parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
            parameters.alphaToCoverage ? '#define ALPHA_TO_COVERAGE' : '',
            parameters.map ? '#define USE_MAP' : '',
            parameters.matcap ? '#define USE_MATCAP' : '',
            parameters.envMap ? '#define USE_ENVMAP' : '',
            parameters.envMap ? '#define ' + envMapTypeDefine : '',
            parameters.envMap ? '#define ' + envMapModeDefine : '',
            parameters.envMap ? '#define ' + envMapBlendingDefine : '',
            envMapCubeUVSize ? '#define CUBEUV_TEXEL_WIDTH ' + envMapCubeUVSize.texelWidth : '',
            envMapCubeUVSize ? '#define CUBEUV_TEXEL_HEIGHT ' + envMapCubeUVSize.texelHeight : '',
            envMapCubeUVSize ? '#define CUBEUV_MAX_MIP ' + envMapCubeUVSize.maxMip + '.0' : '',
            parameters.lightMap ? '#define USE_LIGHTMAP' : '',
            parameters.aoMap ? '#define USE_AOMAP' : '',
            parameters.bumpMap ? '#define USE_BUMPMAP' : '',
            parameters.normalMap ? '#define USE_NORMALMAP' : '',
            parameters.normalMapObjectSpace ? '#define USE_NORMALMAP_OBJECTSPACE' : '',
            parameters.normalMapTangentSpace ? '#define USE_NORMALMAP_TANGENTSPACE' : '',
            parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
            parameters.anisotropy ? '#define USE_ANISOTROPY' : '',
            parameters.anisotropyMap ? '#define USE_ANISOTROPYMAP' : '',
            parameters.clearcoat ? '#define USE_CLEARCOAT' : '',
            parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
            parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
            parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
            parameters.dispersion ? '#define USE_DISPERSION' : '',
            parameters.iridescence ? '#define USE_IRIDESCENCE' : '',
            parameters.iridescenceMap ? '#define USE_IRIDESCENCEMAP' : '',
            parameters.iridescenceThicknessMap ? '#define USE_IRIDESCENCE_THICKNESSMAP' : '',
            parameters.specularMap ? '#define USE_SPECULARMAP' : '',
            parameters.specularColorMap ? '#define USE_SPECULAR_COLORMAP' : '',
            parameters.specularIntensityMap ? '#define USE_SPECULAR_INTENSITYMAP' : '',
            parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
            parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
            parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
            parameters.alphaTest ? '#define USE_ALPHATEST' : '',
            parameters.alphaHash ? '#define USE_ALPHAHASH' : '',
            parameters.sheen ? '#define USE_SHEEN' : '',
            parameters.sheenColorMap ? '#define USE_SHEEN_COLORMAP' : '',
            parameters.sheenRoughnessMap ? '#define USE_SHEEN_ROUGHNESSMAP' : '',
            parameters.transmission ? '#define USE_TRANSMISSION' : '',
            parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
            parameters.thicknessMap ? '#define USE_THICKNESSMAP' : '',
            parameters.vertexTangents && parameters.flatShading === false ? '#define USE_TANGENT' : '',
            parameters.vertexColors || parameters.instancingColor || parameters.batchingColor ? '#define USE_COLOR' : '',
            parameters.vertexAlphas ? '#define USE_COLOR_ALPHA' : '',
            parameters.vertexUv1s ? '#define USE_UV1' : '',
            parameters.vertexUv2s ? '#define USE_UV2' : '',
            parameters.vertexUv3s ? '#define USE_UV3' : '',
            parameters.pointsUvs ? '#define USE_POINTS_UV' : '',
            parameters.gradientMap ? '#define USE_GRADIENTMAP' : '',
            parameters.flatShading ? '#define FLAT_SHADED' : '',
            parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
            parameters.flipSided ? '#define FLIP_SIDED' : '',
            parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
            parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
            parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',
            parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
            parameters.decodeVideoTexture ? '#define DECODE_VIDEO_TEXTURE' : '',
            parameters.decodeVideoTextureEmissive ? '#define DECODE_VIDEO_TEXTURE_EMISSIVE' : '',
            parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
            parameters.reverseDepthBuffer ? '#define USE_REVERSEDEPTHBUF' : '',
            'uniform mat4 viewMatrix;',
            'uniform vec3 cameraPosition;',
            'uniform bool isOrthographic;',
            parameters.toneMapping !== (0, $d5b85d29c0b78636$export$9fcb6b4294603b2) ? '#define TONE_MAPPING' : '',
            parameters.toneMapping !== (0, $d5b85d29c0b78636$export$9fcb6b4294603b2) ? $3dd44ec8564e7230$export$955f9f2e84c43c8b['tonemapping_pars_fragment'] : '',
            parameters.toneMapping !== (0, $d5b85d29c0b78636$export$9fcb6b4294603b2) ? $3dd44ec8564e7230$var$getToneMappingFunction('toneMapping', parameters.toneMapping) : '',
            parameters.dithering ? '#define DITHERING' : '',
            parameters.opaque ? '#define OPAQUE' : '',
            $3dd44ec8564e7230$export$955f9f2e84c43c8b['colorspace_pars_fragment'],
            $3dd44ec8564e7230$var$getTexelEncodingFunction('linearToOutputTexel', parameters.outputColorSpace),
            $3dd44ec8564e7230$var$getLuminanceFunction(),
            parameters.useDepthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',
            '\n'
        ].filter($3dd44ec8564e7230$var$filterEmptyLine).join('\n');
    }
    vertexShader = $3dd44ec8564e7230$var$resolveIncludes(vertexShader);
    vertexShader = $3dd44ec8564e7230$var$replaceLightNums(vertexShader, parameters);
    vertexShader = $3dd44ec8564e7230$var$replaceClippingPlaneNums(vertexShader, parameters);
    fragmentShader = $3dd44ec8564e7230$var$resolveIncludes(fragmentShader);
    fragmentShader = $3dd44ec8564e7230$var$replaceLightNums(fragmentShader, parameters);
    fragmentShader = $3dd44ec8564e7230$var$replaceClippingPlaneNums(fragmentShader, parameters);
    vertexShader = $3dd44ec8564e7230$var$unrollLoops(vertexShader);
    fragmentShader = $3dd44ec8564e7230$var$unrollLoops(fragmentShader);
    if (parameters.isRawShaderMaterial !== true) {
        // GLSL 3.0 conversion for built-in materials and ShaderMaterial
        versionString = '#version 300 es\n';
        prefixVertex = [
            customVertexExtensions,
            '#define attribute in',
            '#define varying out',
            '#define texture2D texture'
        ].join('\n') + '\n' + prefixVertex;
        prefixFragment = [
            '#define varying in',
            parameters.glslVersion === (0, $d5b85d29c0b78636$export$f63012db5506e7dd) ? '' : 'layout(location = 0) out highp vec4 pc_fragColor;',
            parameters.glslVersion === (0, $d5b85d29c0b78636$export$f63012db5506e7dd) ? '' : '#define gl_FragColor pc_fragColor',
            '#define gl_FragDepthEXT gl_FragDepth',
            '#define texture2D texture',
            '#define textureCube texture',
            '#define texture2DProj textureProj',
            '#define texture2DLodEXT textureLod',
            '#define texture2DProjLodEXT textureProjLod',
            '#define textureCubeLodEXT textureLod',
            '#define texture2DGradEXT textureGrad',
            '#define texture2DProjGradEXT textureProjGrad',
            '#define textureCubeGradEXT textureGrad'
        ].join('\n') + '\n' + prefixFragment;
    }
    const vertexGlsl = versionString + prefixVertex + vertexShader;
    const fragmentGlsl = versionString + prefixFragment + fragmentShader;
    // console.log( '*VERTEX*', vertexGlsl );
    // console.log( '*FRAGMENT*', fragmentGlsl );
    const glVertexShader = $3dd44ec8564e7230$var$WebGLShader(gl, gl.VERTEX_SHADER, vertexGlsl);
    const glFragmentShader = $3dd44ec8564e7230$var$WebGLShader(gl, gl.FRAGMENT_SHADER, fragmentGlsl);
    gl.attachShader(program, glVertexShader);
    gl.attachShader(program, glFragmentShader);
    // Force a particular attribute to index 0.
    if (parameters.index0AttributeName !== undefined) gl.bindAttribLocation(program, 0, parameters.index0AttributeName);
    else if (parameters.morphTargets === true) // programs with morphTargets displace position out of attribute 0
    gl.bindAttribLocation(program, 0, 'position');
    gl.linkProgram(program);
    function onFirstUse(self1) {
        // check for link errors
        if (renderer.debug.checkShaderErrors) {
            const programLog = gl.getProgramInfoLog(program).trim();
            const vertexLog = gl.getShaderInfoLog(glVertexShader).trim();
            const fragmentLog = gl.getShaderInfoLog(glFragmentShader).trim();
            let runnable = true;
            let haveDiagnostics = true;
            if (gl.getProgramParameter(program, gl.LINK_STATUS) === false) {
                runnable = false;
                if (typeof renderer.debug.onShaderError === 'function') renderer.debug.onShaderError(gl, program, glVertexShader, glFragmentShader);
                else {
                    // default error reporting
                    const vertexErrors = $3dd44ec8564e7230$var$getShaderErrors(gl, glVertexShader, 'vertex');
                    const fragmentErrors = $3dd44ec8564e7230$var$getShaderErrors(gl, glFragmentShader, 'fragment');
                    console.error('THREE.WebGLProgram: Shader Error ' + gl.getError() + ' - ' + 'VALIDATE_STATUS ' + gl.getProgramParameter(program, gl.VALIDATE_STATUS) + '\n\n' + 'Material Name: ' + self1.name + '\n' + 'Material Type: ' + self1.type + '\n\n' + 'Program Info Log: ' + programLog + '\n' + vertexErrors + '\n' + fragmentErrors);
                }
            } else if (programLog !== '') console.warn('THREE.WebGLProgram: Program Info Log:', programLog);
            else if (vertexLog === '' || fragmentLog === '') haveDiagnostics = false;
            if (haveDiagnostics) self1.diagnostics = {
                runnable: runnable,
                programLog: programLog,
                vertexShader: {
                    log: vertexLog,
                    prefix: prefixVertex
                },
                fragmentShader: {
                    log: fragmentLog,
                    prefix: prefixFragment
                }
            };
        }
        // Clean up
        // Crashes in iOS9 and iOS10. #18402
        // gl.detachShader( program, glVertexShader );
        // gl.detachShader( program, glFragmentShader );
        gl.deleteShader(glVertexShader);
        gl.deleteShader(glFragmentShader);
        cachedUniforms = new $3dd44ec8564e7230$var$WebGLUniforms(gl, program);
        cachedAttributes = $3dd44ec8564e7230$var$fetchAttributeLocations(gl, program);
    }
    // set up caching for uniform locations
    let cachedUniforms;
    this.getUniforms = function() {
        if (cachedUniforms === undefined) // Populates cachedUniforms and cachedAttributes
        onFirstUse(this);
        return cachedUniforms;
    };
    // set up caching for attribute locations
    let cachedAttributes;
    this.getAttributes = function() {
        if (cachedAttributes === undefined) // Populates cachedAttributes and cachedUniforms
        onFirstUse(this);
        return cachedAttributes;
    };
    // indicate when the program is ready to be used. if the KHR_parallel_shader_compile extension isn't supported,
    // flag the program as ready immediately. It may cause a stall when it's first used.
    let programReady = parameters.rendererExtensionParallelShaderCompile === false;
    this.isReady = function() {
        if (programReady === false) programReady = gl.getProgramParameter(program, $3dd44ec8564e7230$var$COMPLETION_STATUS_KHR);
        return programReady;
    };
    // free resource
    this.destroy = function() {
        bindingStates.releaseStatesOfProgram(this);
        gl.deleteProgram(program);
        this.program = undefined;
    };
    //
    this.type = parameters.shaderType;
    this.name = parameters.shaderName;
    this.id = $3dd44ec8564e7230$var$programIdCount++;
    this.cacheKey = cacheKey;
    this.usedTimes = 1;
    this.program = program;
    this.vertexShader = glVertexShader;
    this.fragmentShader = glFragmentShader;
    return this;
}
let $3dd44ec8564e7230$var$_id = 0;
class $3dd44ec8564e7230$var$WebGLShaderCache {
    constructor(){
        this.shaderCache = new Map();
        this.materialCache = new Map();
    }
    update(material) {
        const vertexShader = material.vertexShader;
        const fragmentShader = material.fragmentShader;
        const vertexShaderStage = this._getShaderStage(vertexShader);
        const fragmentShaderStage = this._getShaderStage(fragmentShader);
        const materialShaders = this._getShaderCacheForMaterial(material);
        if (materialShaders.has(vertexShaderStage) === false) {
            materialShaders.add(vertexShaderStage);
            vertexShaderStage.usedTimes++;
        }
        if (materialShaders.has(fragmentShaderStage) === false) {
            materialShaders.add(fragmentShaderStage);
            fragmentShaderStage.usedTimes++;
        }
        return this;
    }
    remove(material) {
        const materialShaders = this.materialCache.get(material);
        for (const shaderStage of materialShaders){
            shaderStage.usedTimes--;
            if (shaderStage.usedTimes === 0) this.shaderCache.delete(shaderStage.code);
        }
        this.materialCache.delete(material);
        return this;
    }
    getVertexShaderID(material) {
        return this._getShaderStage(material.vertexShader).id;
    }
    getFragmentShaderID(material) {
        return this._getShaderStage(material.fragmentShader).id;
    }
    dispose() {
        this.shaderCache.clear();
        this.materialCache.clear();
    }
    _getShaderCacheForMaterial(material) {
        const cache = this.materialCache;
        let set = cache.get(material);
        if (set === undefined) {
            set = new Set();
            cache.set(material, set);
        }
        return set;
    }
    _getShaderStage(code) {
        const cache = this.shaderCache;
        let stage = cache.get(code);
        if (stage === undefined) {
            stage = new $3dd44ec8564e7230$var$WebGLShaderStage(code);
            cache.set(code, stage);
        }
        return stage;
    }
}
class $3dd44ec8564e7230$var$WebGLShaderStage {
    constructor(code){
        this.id = $3dd44ec8564e7230$var$_id++;
        this.code = code;
        this.usedTimes = 0;
    }
}
function $3dd44ec8564e7230$var$WebGLPrograms(renderer, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping) {
    const _programLayers = new (0, $d5b85d29c0b78636$export$89312ce47c0ca777)();
    const _customShaders = new $3dd44ec8564e7230$var$WebGLShaderCache();
    const _activeChannels = new Set();
    const programs = [];
    const logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;
    const SUPPORTS_VERTEX_TEXTURES = capabilities.vertexTextures;
    let precision = capabilities.precision;
    const shaderIDs = {
        MeshDepthMaterial: 'depth',
        MeshDistanceMaterial: 'distanceRGBA',
        MeshNormalMaterial: 'normal',
        MeshBasicMaterial: 'basic',
        MeshLambertMaterial: 'lambert',
        MeshPhongMaterial: 'phong',
        MeshToonMaterial: 'toon',
        MeshStandardMaterial: 'physical',
        MeshPhysicalMaterial: 'physical',
        MeshMatcapMaterial: 'matcap',
        LineBasicMaterial: 'basic',
        LineDashedMaterial: 'dashed',
        PointsMaterial: 'points',
        ShadowMaterial: 'shadow',
        SpriteMaterial: 'sprite'
    };
    function getChannel(value) {
        _activeChannels.add(value);
        if (value === 0) return 'uv';
        return `uv${value}`;
    }
    function getParameters(material, lights, shadows, scene, object) {
        const fog = scene.fog;
        const geometry = object.geometry;
        const environment = material.isMeshStandardMaterial ? scene.environment : null;
        const envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || environment);
        const envMapCubeUVHeight = !!envMap && envMap.mapping === (0, $d5b85d29c0b78636$export$dbf3e70ff37af79) ? envMap.image.height : null;
        const shaderID = shaderIDs[material.type];
        // heuristics to create shader parameters according to lights in the scene
        // (not to blow over maxLights budget)
        if (material.precision !== null) {
            precision = capabilities.getMaxPrecision(material.precision);
            if (precision !== material.precision) console.warn('THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.');
        }
        //
        const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
        const morphTargetsCount = morphAttribute !== undefined ? morphAttribute.length : 0;
        let morphTextureStride = 0;
        if (geometry.morphAttributes.position !== undefined) morphTextureStride = 1;
        if (geometry.morphAttributes.normal !== undefined) morphTextureStride = 2;
        if (geometry.morphAttributes.color !== undefined) morphTextureStride = 3;
        //
        let vertexShader, fragmentShader;
        let customVertexShaderID, customFragmentShaderID;
        if (shaderID) {
            const shader = $3dd44ec8564e7230$export$bee4a7d47f8f5014[shaderID];
            vertexShader = shader.vertexShader;
            fragmentShader = shader.fragmentShader;
        } else {
            vertexShader = material.vertexShader;
            fragmentShader = material.fragmentShader;
            _customShaders.update(material);
            customVertexShaderID = _customShaders.getVertexShaderID(material);
            customFragmentShaderID = _customShaders.getFragmentShaderID(material);
        }
        const currentRenderTarget = renderer.getRenderTarget();
        const reverseDepthBuffer = renderer.state.buffers.depth.getReversed();
        const IS_INSTANCEDMESH = object.isInstancedMesh === true;
        const IS_BATCHEDMESH = object.isBatchedMesh === true;
        const HAS_MAP = !!material.map;
        const HAS_MATCAP = !!material.matcap;
        const HAS_ENVMAP = !!envMap;
        const HAS_AOMAP = !!material.aoMap;
        const HAS_LIGHTMAP = !!material.lightMap;
        const HAS_BUMPMAP = !!material.bumpMap;
        const HAS_NORMALMAP = !!material.normalMap;
        const HAS_DISPLACEMENTMAP = !!material.displacementMap;
        const HAS_EMISSIVEMAP = !!material.emissiveMap;
        const HAS_METALNESSMAP = !!material.metalnessMap;
        const HAS_ROUGHNESSMAP = !!material.roughnessMap;
        const HAS_ANISOTROPY = material.anisotropy > 0;
        const HAS_CLEARCOAT = material.clearcoat > 0;
        const HAS_DISPERSION = material.dispersion > 0;
        const HAS_IRIDESCENCE = material.iridescence > 0;
        const HAS_SHEEN = material.sheen > 0;
        const HAS_TRANSMISSION = material.transmission > 0;
        const HAS_ANISOTROPYMAP = HAS_ANISOTROPY && !!material.anisotropyMap;
        const HAS_CLEARCOATMAP = HAS_CLEARCOAT && !!material.clearcoatMap;
        const HAS_CLEARCOAT_NORMALMAP = HAS_CLEARCOAT && !!material.clearcoatNormalMap;
        const HAS_CLEARCOAT_ROUGHNESSMAP = HAS_CLEARCOAT && !!material.clearcoatRoughnessMap;
        const HAS_IRIDESCENCEMAP = HAS_IRIDESCENCE && !!material.iridescenceMap;
        const HAS_IRIDESCENCE_THICKNESSMAP = HAS_IRIDESCENCE && !!material.iridescenceThicknessMap;
        const HAS_SHEEN_COLORMAP = HAS_SHEEN && !!material.sheenColorMap;
        const HAS_SHEEN_ROUGHNESSMAP = HAS_SHEEN && !!material.sheenRoughnessMap;
        const HAS_SPECULARMAP = !!material.specularMap;
        const HAS_SPECULAR_COLORMAP = !!material.specularColorMap;
        const HAS_SPECULAR_INTENSITYMAP = !!material.specularIntensityMap;
        const HAS_TRANSMISSIONMAP = HAS_TRANSMISSION && !!material.transmissionMap;
        const HAS_THICKNESSMAP = HAS_TRANSMISSION && !!material.thicknessMap;
        const HAS_GRADIENTMAP = !!material.gradientMap;
        const HAS_ALPHAMAP = !!material.alphaMap;
        const HAS_ALPHATEST = material.alphaTest > 0;
        const HAS_ALPHAHASH = !!material.alphaHash;
        const HAS_EXTENSIONS = !!material.extensions;
        let toneMapping = (0, $d5b85d29c0b78636$export$9fcb6b4294603b2);
        if (material.toneMapped) {
            if (currentRenderTarget === null || currentRenderTarget.isXRRenderTarget === true) toneMapping = renderer.toneMapping;
        }
        const parameters = {
            shaderID: shaderID,
            shaderType: material.type,
            shaderName: material.name,
            vertexShader: vertexShader,
            fragmentShader: fragmentShader,
            defines: material.defines,
            customVertexShaderID: customVertexShaderID,
            customFragmentShaderID: customFragmentShaderID,
            isRawShaderMaterial: material.isRawShaderMaterial === true,
            glslVersion: material.glslVersion,
            precision: precision,
            batching: IS_BATCHEDMESH,
            batchingColor: IS_BATCHEDMESH && object._colorsTexture !== null,
            instancing: IS_INSTANCEDMESH,
            instancingColor: IS_INSTANCEDMESH && object.instanceColor !== null,
            instancingMorph: IS_INSTANCEDMESH && object.morphTexture !== null,
            supportsVertexTextures: SUPPORTS_VERTEX_TEXTURES,
            outputColorSpace: currentRenderTarget === null ? renderer.outputColorSpace : currentRenderTarget.isXRRenderTarget === true ? currentRenderTarget.texture.colorSpace : (0, $d5b85d29c0b78636$export$42429b3acfb233a4),
            alphaToCoverage: !!material.alphaToCoverage,
            map: HAS_MAP,
            matcap: HAS_MATCAP,
            envMap: HAS_ENVMAP,
            envMapMode: HAS_ENVMAP && envMap.mapping,
            envMapCubeUVHeight: envMapCubeUVHeight,
            aoMap: HAS_AOMAP,
            lightMap: HAS_LIGHTMAP,
            bumpMap: HAS_BUMPMAP,
            normalMap: HAS_NORMALMAP,
            displacementMap: SUPPORTS_VERTEX_TEXTURES && HAS_DISPLACEMENTMAP,
            emissiveMap: HAS_EMISSIVEMAP,
            normalMapObjectSpace: HAS_NORMALMAP && material.normalMapType === (0, $d5b85d29c0b78636$export$9990ad26f9db5b2c),
            normalMapTangentSpace: HAS_NORMALMAP && material.normalMapType === (0, $d5b85d29c0b78636$export$2852a58ebdac27b8),
            metalnessMap: HAS_METALNESSMAP,
            roughnessMap: HAS_ROUGHNESSMAP,
            anisotropy: HAS_ANISOTROPY,
            anisotropyMap: HAS_ANISOTROPYMAP,
            clearcoat: HAS_CLEARCOAT,
            clearcoatMap: HAS_CLEARCOATMAP,
            clearcoatNormalMap: HAS_CLEARCOAT_NORMALMAP,
            clearcoatRoughnessMap: HAS_CLEARCOAT_ROUGHNESSMAP,
            dispersion: HAS_DISPERSION,
            iridescence: HAS_IRIDESCENCE,
            iridescenceMap: HAS_IRIDESCENCEMAP,
            iridescenceThicknessMap: HAS_IRIDESCENCE_THICKNESSMAP,
            sheen: HAS_SHEEN,
            sheenColorMap: HAS_SHEEN_COLORMAP,
            sheenRoughnessMap: HAS_SHEEN_ROUGHNESSMAP,
            specularMap: HAS_SPECULARMAP,
            specularColorMap: HAS_SPECULAR_COLORMAP,
            specularIntensityMap: HAS_SPECULAR_INTENSITYMAP,
            transmission: HAS_TRANSMISSION,
            transmissionMap: HAS_TRANSMISSIONMAP,
            thicknessMap: HAS_THICKNESSMAP,
            gradientMap: HAS_GRADIENTMAP,
            opaque: material.transparent === false && material.blending === (0, $d5b85d29c0b78636$export$5b29a26d96ee6af0) && material.alphaToCoverage === false,
            alphaMap: HAS_ALPHAMAP,
            alphaTest: HAS_ALPHATEST,
            alphaHash: HAS_ALPHAHASH,
            combine: material.combine,
            //
            mapUv: HAS_MAP && getChannel(material.map.channel),
            aoMapUv: HAS_AOMAP && getChannel(material.aoMap.channel),
            lightMapUv: HAS_LIGHTMAP && getChannel(material.lightMap.channel),
            bumpMapUv: HAS_BUMPMAP && getChannel(material.bumpMap.channel),
            normalMapUv: HAS_NORMALMAP && getChannel(material.normalMap.channel),
            displacementMapUv: HAS_DISPLACEMENTMAP && getChannel(material.displacementMap.channel),
            emissiveMapUv: HAS_EMISSIVEMAP && getChannel(material.emissiveMap.channel),
            metalnessMapUv: HAS_METALNESSMAP && getChannel(material.metalnessMap.channel),
            roughnessMapUv: HAS_ROUGHNESSMAP && getChannel(material.roughnessMap.channel),
            anisotropyMapUv: HAS_ANISOTROPYMAP && getChannel(material.anisotropyMap.channel),
            clearcoatMapUv: HAS_CLEARCOATMAP && getChannel(material.clearcoatMap.channel),
            clearcoatNormalMapUv: HAS_CLEARCOAT_NORMALMAP && getChannel(material.clearcoatNormalMap.channel),
            clearcoatRoughnessMapUv: HAS_CLEARCOAT_ROUGHNESSMAP && getChannel(material.clearcoatRoughnessMap.channel),
            iridescenceMapUv: HAS_IRIDESCENCEMAP && getChannel(material.iridescenceMap.channel),
            iridescenceThicknessMapUv: HAS_IRIDESCENCE_THICKNESSMAP && getChannel(material.iridescenceThicknessMap.channel),
            sheenColorMapUv: HAS_SHEEN_COLORMAP && getChannel(material.sheenColorMap.channel),
            sheenRoughnessMapUv: HAS_SHEEN_ROUGHNESSMAP && getChannel(material.sheenRoughnessMap.channel),
            specularMapUv: HAS_SPECULARMAP && getChannel(material.specularMap.channel),
            specularColorMapUv: HAS_SPECULAR_COLORMAP && getChannel(material.specularColorMap.channel),
            specularIntensityMapUv: HAS_SPECULAR_INTENSITYMAP && getChannel(material.specularIntensityMap.channel),
            transmissionMapUv: HAS_TRANSMISSIONMAP && getChannel(material.transmissionMap.channel),
            thicknessMapUv: HAS_THICKNESSMAP && getChannel(material.thicknessMap.channel),
            alphaMapUv: HAS_ALPHAMAP && getChannel(material.alphaMap.channel),
            //
            vertexTangents: !!geometry.attributes.tangent && (HAS_NORMALMAP || HAS_ANISOTROPY),
            vertexColors: material.vertexColors,
            vertexAlphas: material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4,
            pointsUvs: object.isPoints === true && !!geometry.attributes.uv && (HAS_MAP || HAS_ALPHAMAP),
            fog: !!fog,
            useFog: material.fog === true,
            fogExp2: !!fog && fog.isFogExp2,
            flatShading: material.flatShading === true,
            sizeAttenuation: material.sizeAttenuation === true,
            logarithmicDepthBuffer: logarithmicDepthBuffer,
            reverseDepthBuffer: reverseDepthBuffer,
            skinning: object.isSkinnedMesh === true,
            morphTargets: geometry.morphAttributes.position !== undefined,
            morphNormals: geometry.morphAttributes.normal !== undefined,
            morphColors: geometry.morphAttributes.color !== undefined,
            morphTargetsCount: morphTargetsCount,
            morphTextureStride: morphTextureStride,
            numDirLights: lights.directional.length,
            numPointLights: lights.point.length,
            numSpotLights: lights.spot.length,
            numSpotLightMaps: lights.spotLightMap.length,
            numRectAreaLights: lights.rectArea.length,
            numHemiLights: lights.hemi.length,
            numDirLightShadows: lights.directionalShadowMap.length,
            numPointLightShadows: lights.pointShadowMap.length,
            numSpotLightShadows: lights.spotShadowMap.length,
            numSpotLightShadowsWithMaps: lights.numSpotLightShadowsWithMaps,
            numLightProbes: lights.numLightProbes,
            numClippingPlanes: clipping.numPlanes,
            numClipIntersection: clipping.numIntersection,
            dithering: material.dithering,
            shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,
            shadowMapType: renderer.shadowMap.type,
            toneMapping: toneMapping,
            decodeVideoTexture: HAS_MAP && material.map.isVideoTexture === true && (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(material.map.colorSpace) === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb),
            decodeVideoTextureEmissive: HAS_EMISSIVEMAP && material.emissiveMap.isVideoTexture === true && (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(material.emissiveMap.colorSpace) === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb),
            premultipliedAlpha: material.premultipliedAlpha,
            doubleSided: material.side === (0, $d5b85d29c0b78636$export$3b296b6f144d5b03),
            flipSided: material.side === (0, $d5b85d29c0b78636$export$d9f0486e75b5ace),
            useDepthPacking: material.depthPacking >= 0,
            depthPacking: material.depthPacking || 0,
            index0AttributeName: material.index0AttributeName,
            extensionClipCullDistance: HAS_EXTENSIONS && material.extensions.clipCullDistance === true && extensions.has('WEBGL_clip_cull_distance'),
            extensionMultiDraw: (HAS_EXTENSIONS && material.extensions.multiDraw === true || IS_BATCHEDMESH) && extensions.has('WEBGL_multi_draw'),
            rendererExtensionParallelShaderCompile: extensions.has('KHR_parallel_shader_compile'),
            customProgramCacheKey: material.customProgramCacheKey()
        };
        // the usage of getChannel() determines the active texture channels for this shader
        parameters.vertexUv1s = _activeChannels.has(1);
        parameters.vertexUv2s = _activeChannels.has(2);
        parameters.vertexUv3s = _activeChannels.has(3);
        _activeChannels.clear();
        return parameters;
    }
    function getProgramCacheKey(parameters) {
        const array = [];
        if (parameters.shaderID) array.push(parameters.shaderID);
        else {
            array.push(parameters.customVertexShaderID);
            array.push(parameters.customFragmentShaderID);
        }
        if (parameters.defines !== undefined) for(const name in parameters.defines){
            array.push(name);
            array.push(parameters.defines[name]);
        }
        if (parameters.isRawShaderMaterial === false) {
            getProgramCacheKeyParameters(array, parameters);
            getProgramCacheKeyBooleans(array, parameters);
            array.push(renderer.outputColorSpace);
        }
        array.push(parameters.customProgramCacheKey);
        return array.join();
    }
    function getProgramCacheKeyParameters(array, parameters) {
        array.push(parameters.precision);
        array.push(parameters.outputColorSpace);
        array.push(parameters.envMapMode);
        array.push(parameters.envMapCubeUVHeight);
        array.push(parameters.mapUv);
        array.push(parameters.alphaMapUv);
        array.push(parameters.lightMapUv);
        array.push(parameters.aoMapUv);
        array.push(parameters.bumpMapUv);
        array.push(parameters.normalMapUv);
        array.push(parameters.displacementMapUv);
        array.push(parameters.emissiveMapUv);
        array.push(parameters.metalnessMapUv);
        array.push(parameters.roughnessMapUv);
        array.push(parameters.anisotropyMapUv);
        array.push(parameters.clearcoatMapUv);
        array.push(parameters.clearcoatNormalMapUv);
        array.push(parameters.clearcoatRoughnessMapUv);
        array.push(parameters.iridescenceMapUv);
        array.push(parameters.iridescenceThicknessMapUv);
        array.push(parameters.sheenColorMapUv);
        array.push(parameters.sheenRoughnessMapUv);
        array.push(parameters.specularMapUv);
        array.push(parameters.specularColorMapUv);
        array.push(parameters.specularIntensityMapUv);
        array.push(parameters.transmissionMapUv);
        array.push(parameters.thicknessMapUv);
        array.push(parameters.combine);
        array.push(parameters.fogExp2);
        array.push(parameters.sizeAttenuation);
        array.push(parameters.morphTargetsCount);
        array.push(parameters.morphAttributeCount);
        array.push(parameters.numDirLights);
        array.push(parameters.numPointLights);
        array.push(parameters.numSpotLights);
        array.push(parameters.numSpotLightMaps);
        array.push(parameters.numHemiLights);
        array.push(parameters.numRectAreaLights);
        array.push(parameters.numDirLightShadows);
        array.push(parameters.numPointLightShadows);
        array.push(parameters.numSpotLightShadows);
        array.push(parameters.numSpotLightShadowsWithMaps);
        array.push(parameters.numLightProbes);
        array.push(parameters.shadowMapType);
        array.push(parameters.toneMapping);
        array.push(parameters.numClippingPlanes);
        array.push(parameters.numClipIntersection);
        array.push(parameters.depthPacking);
    }
    function getProgramCacheKeyBooleans(array, parameters) {
        _programLayers.disableAll();
        if (parameters.supportsVertexTextures) _programLayers.enable(0);
        if (parameters.instancing) _programLayers.enable(1);
        if (parameters.instancingColor) _programLayers.enable(2);
        if (parameters.instancingMorph) _programLayers.enable(3);
        if (parameters.matcap) _programLayers.enable(4);
        if (parameters.envMap) _programLayers.enable(5);
        if (parameters.normalMapObjectSpace) _programLayers.enable(6);
        if (parameters.normalMapTangentSpace) _programLayers.enable(7);
        if (parameters.clearcoat) _programLayers.enable(8);
        if (parameters.iridescence) _programLayers.enable(9);
        if (parameters.alphaTest) _programLayers.enable(10);
        if (parameters.vertexColors) _programLayers.enable(11);
        if (parameters.vertexAlphas) _programLayers.enable(12);
        if (parameters.vertexUv1s) _programLayers.enable(13);
        if (parameters.vertexUv2s) _programLayers.enable(14);
        if (parameters.vertexUv3s) _programLayers.enable(15);
        if (parameters.vertexTangents) _programLayers.enable(16);
        if (parameters.anisotropy) _programLayers.enable(17);
        if (parameters.alphaHash) _programLayers.enable(18);
        if (parameters.batching) _programLayers.enable(19);
        if (parameters.dispersion) _programLayers.enable(20);
        if (parameters.batchingColor) _programLayers.enable(21);
        array.push(_programLayers.mask);
        _programLayers.disableAll();
        if (parameters.fog) _programLayers.enable(0);
        if (parameters.useFog) _programLayers.enable(1);
        if (parameters.flatShading) _programLayers.enable(2);
        if (parameters.logarithmicDepthBuffer) _programLayers.enable(3);
        if (parameters.reverseDepthBuffer) _programLayers.enable(4);
        if (parameters.skinning) _programLayers.enable(5);
        if (parameters.morphTargets) _programLayers.enable(6);
        if (parameters.morphNormals) _programLayers.enable(7);
        if (parameters.morphColors) _programLayers.enable(8);
        if (parameters.premultipliedAlpha) _programLayers.enable(9);
        if (parameters.shadowMapEnabled) _programLayers.enable(10);
        if (parameters.doubleSided) _programLayers.enable(11);
        if (parameters.flipSided) _programLayers.enable(12);
        if (parameters.useDepthPacking) _programLayers.enable(13);
        if (parameters.dithering) _programLayers.enable(14);
        if (parameters.transmission) _programLayers.enable(15);
        if (parameters.sheen) _programLayers.enable(16);
        if (parameters.opaque) _programLayers.enable(17);
        if (parameters.pointsUvs) _programLayers.enable(18);
        if (parameters.decodeVideoTexture) _programLayers.enable(19);
        if (parameters.decodeVideoTextureEmissive) _programLayers.enable(20);
        if (parameters.alphaToCoverage) _programLayers.enable(21);
        array.push(_programLayers.mask);
    }
    function getUniforms(material) {
        const shaderID = shaderIDs[material.type];
        let uniforms;
        if (shaderID) {
            const shader = $3dd44ec8564e7230$export$bee4a7d47f8f5014[shaderID];
            uniforms = (0, $d5b85d29c0b78636$export$d8ecdf8615bfea69).clone(shader.uniforms);
        } else uniforms = material.uniforms;
        return uniforms;
    }
    function acquireProgram(parameters, cacheKey) {
        let program;
        // Check if code has been already compiled
        for(let p = 0, pl = programs.length; p < pl; p++){
            const preexistingProgram = programs[p];
            if (preexistingProgram.cacheKey === cacheKey) {
                program = preexistingProgram;
                ++program.usedTimes;
                break;
            }
        }
        if (program === undefined) {
            program = new $3dd44ec8564e7230$var$WebGLProgram(renderer, cacheKey, parameters, bindingStates);
            programs.push(program);
        }
        return program;
    }
    function releaseProgram(program) {
        if (--program.usedTimes === 0) {
            // Remove from unordered set
            const i = programs.indexOf(program);
            programs[i] = programs[programs.length - 1];
            programs.pop();
            // Free WebGL resources
            program.destroy();
        }
    }
    function releaseShaderCache(material) {
        _customShaders.remove(material);
    }
    function dispose() {
        _customShaders.dispose();
    }
    return {
        getParameters: getParameters,
        getProgramCacheKey: getProgramCacheKey,
        getUniforms: getUniforms,
        acquireProgram: acquireProgram,
        releaseProgram: releaseProgram,
        releaseShaderCache: releaseShaderCache,
        // Exposed for resource monitoring & error feedback via renderer.info:
        programs: programs,
        dispose: dispose
    };
}
function $3dd44ec8564e7230$var$WebGLProperties() {
    let properties = new WeakMap();
    function has(object) {
        return properties.has(object);
    }
    function get(object) {
        let map = properties.get(object);
        if (map === undefined) {
            map = {};
            properties.set(object, map);
        }
        return map;
    }
    function remove(object) {
        properties.delete(object);
    }
    function update(object, key, value) {
        properties.get(object)[key] = value;
    }
    function dispose() {
        properties = new WeakMap();
    }
    return {
        has: has,
        get: get,
        remove: remove,
        update: update,
        dispose: dispose
    };
}
function $3dd44ec8564e7230$var$painterSortStable(a, b) {
    if (a.groupOrder !== b.groupOrder) return a.groupOrder - b.groupOrder;
    else if (a.renderOrder !== b.renderOrder) return a.renderOrder - b.renderOrder;
    else if (a.material.id !== b.material.id) return a.material.id - b.material.id;
    else if (a.z !== b.z) return a.z - b.z;
    else return a.id - b.id;
}
function $3dd44ec8564e7230$var$reversePainterSortStable(a, b) {
    if (a.groupOrder !== b.groupOrder) return a.groupOrder - b.groupOrder;
    else if (a.renderOrder !== b.renderOrder) return a.renderOrder - b.renderOrder;
    else if (a.z !== b.z) return b.z - a.z;
    else return a.id - b.id;
}
function $3dd44ec8564e7230$var$WebGLRenderList() {
    const renderItems = [];
    let renderItemsIndex = 0;
    const opaque = [];
    const transmissive = [];
    const transparent = [];
    function init() {
        renderItemsIndex = 0;
        opaque.length = 0;
        transmissive.length = 0;
        transparent.length = 0;
    }
    function getNextRenderItem(object, geometry, material, groupOrder, z, group) {
        let renderItem = renderItems[renderItemsIndex];
        if (renderItem === undefined) {
            renderItem = {
                id: object.id,
                object: object,
                geometry: geometry,
                material: material,
                groupOrder: groupOrder,
                renderOrder: object.renderOrder,
                z: z,
                group: group
            };
            renderItems[renderItemsIndex] = renderItem;
        } else {
            renderItem.id = object.id;
            renderItem.object = object;
            renderItem.geometry = geometry;
            renderItem.material = material;
            renderItem.groupOrder = groupOrder;
            renderItem.renderOrder = object.renderOrder;
            renderItem.z = z;
            renderItem.group = group;
        }
        renderItemsIndex++;
        return renderItem;
    }
    function push(object, geometry, material, groupOrder, z, group) {
        const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group);
        if (material.transmission > 0.0) transmissive.push(renderItem);
        else if (material.transparent === true) transparent.push(renderItem);
        else opaque.push(renderItem);
    }
    function unshift(object, geometry, material, groupOrder, z, group) {
        const renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group);
        if (material.transmission > 0.0) transmissive.unshift(renderItem);
        else if (material.transparent === true) transparent.unshift(renderItem);
        else opaque.unshift(renderItem);
    }
    function sort(customOpaqueSort, customTransparentSort) {
        if (opaque.length > 1) opaque.sort(customOpaqueSort || $3dd44ec8564e7230$var$painterSortStable);
        if (transmissive.length > 1) transmissive.sort(customTransparentSort || $3dd44ec8564e7230$var$reversePainterSortStable);
        if (transparent.length > 1) transparent.sort(customTransparentSort || $3dd44ec8564e7230$var$reversePainterSortStable);
    }
    function finish() {
        // Clear references from inactive renderItems in the list
        for(let i = renderItemsIndex, il = renderItems.length; i < il; i++){
            const renderItem = renderItems[i];
            if (renderItem.id === null) break;
            renderItem.id = null;
            renderItem.object = null;
            renderItem.geometry = null;
            renderItem.material = null;
            renderItem.group = null;
        }
    }
    return {
        opaque: opaque,
        transmissive: transmissive,
        transparent: transparent,
        init: init,
        push: push,
        unshift: unshift,
        finish: finish,
        sort: sort
    };
}
function $3dd44ec8564e7230$var$WebGLRenderLists() {
    let lists = new WeakMap();
    function get(scene, renderCallDepth) {
        const listArray = lists.get(scene);
        let list;
        if (listArray === undefined) {
            list = new $3dd44ec8564e7230$var$WebGLRenderList();
            lists.set(scene, [
                list
            ]);
        } else if (renderCallDepth >= listArray.length) {
            list = new $3dd44ec8564e7230$var$WebGLRenderList();
            listArray.push(list);
        } else list = listArray[renderCallDepth];
        return list;
    }
    function dispose() {
        lists = new WeakMap();
    }
    return {
        get: get,
        dispose: dispose
    };
}
function $3dd44ec8564e7230$var$UniformsCache() {
    const lights = {};
    return {
        get: function(light) {
            if (lights[light.id] !== undefined) return lights[light.id];
            let uniforms;
            switch(light.type){
                case 'DirectionalLight':
                    uniforms = {
                        direction: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        color: new (0, $d5b85d29c0b78636$export$892596cec99bc70e)()
                    };
                    break;
                case 'SpotLight':
                    uniforms = {
                        position: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        direction: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        color: new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(),
                        distance: 0,
                        coneCos: 0,
                        penumbraCos: 0,
                        decay: 0
                    };
                    break;
                case 'PointLight':
                    uniforms = {
                        position: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        color: new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(),
                        distance: 0,
                        decay: 0
                    };
                    break;
                case 'HemisphereLight':
                    uniforms = {
                        direction: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        skyColor: new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(),
                        groundColor: new (0, $d5b85d29c0b78636$export$892596cec99bc70e)()
                    };
                    break;
                case 'RectAreaLight':
                    uniforms = {
                        color: new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(),
                        position: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        halfWidth: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)(),
                        halfHeight: new (0, $d5b85d29c0b78636$export$64b5c384219d3699)()
                    };
                    break;
            }
            lights[light.id] = uniforms;
            return uniforms;
        }
    };
}
function $3dd44ec8564e7230$var$ShadowUniformsCache() {
    const lights = {};
    return {
        get: function(light) {
            if (lights[light.id] !== undefined) return lights[light.id];
            let uniforms;
            switch(light.type){
                case 'DirectionalLight':
                    uniforms = {
                        shadowIntensity: 1,
                        shadowBias: 0,
                        shadowNormalBias: 0,
                        shadowRadius: 1,
                        shadowMapSize: new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)()
                    };
                    break;
                case 'SpotLight':
                    uniforms = {
                        shadowIntensity: 1,
                        shadowBias: 0,
                        shadowNormalBias: 0,
                        shadowRadius: 1,
                        shadowMapSize: new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)()
                    };
                    break;
                case 'PointLight':
                    uniforms = {
                        shadowIntensity: 1,
                        shadowBias: 0,
                        shadowNormalBias: 0,
                        shadowRadius: 1,
                        shadowMapSize: new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(),
                        shadowCameraNear: 1,
                        shadowCameraFar: 1000
                    };
                    break;
            }
            lights[light.id] = uniforms;
            return uniforms;
        }
    };
}
let $3dd44ec8564e7230$var$nextVersion = 0;
function $3dd44ec8564e7230$var$shadowCastingAndTexturingLightsFirst(lightA, lightB) {
    return (lightB.castShadow ? 2 : 0) - (lightA.castShadow ? 2 : 0) + (lightB.map ? 1 : 0) - (lightA.map ? 1 : 0);
}
function $3dd44ec8564e7230$var$WebGLLights(extensions) {
    const cache = new $3dd44ec8564e7230$var$UniformsCache();
    const shadowCache = $3dd44ec8564e7230$var$ShadowUniformsCache();
    const state = {
        version: 0,
        hash: {
            directionalLength: -1,
            pointLength: -1,
            spotLength: -1,
            rectAreaLength: -1,
            hemiLength: -1,
            numDirectionalShadows: -1,
            numPointShadows: -1,
            numSpotShadows: -1,
            numSpotMaps: -1,
            numLightProbes: -1
        },
        ambient: [
            0,
            0,
            0
        ],
        probe: [],
        directional: [],
        directionalShadow: [],
        directionalShadowMap: [],
        directionalShadowMatrix: [],
        spot: [],
        spotLightMap: [],
        spotShadow: [],
        spotShadowMap: [],
        spotLightMatrix: [],
        rectArea: [],
        rectAreaLTC1: null,
        rectAreaLTC2: null,
        point: [],
        pointShadow: [],
        pointShadowMap: [],
        pointShadowMatrix: [],
        hemi: [],
        numSpotLightShadowsWithMaps: 0,
        numLightProbes: 0
    };
    for(let i = 0; i < 9; i++)state.probe.push(new (0, $d5b85d29c0b78636$export$64b5c384219d3699)());
    const vector3 = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
    const matrix4 = new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
    const matrix42 = new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
    function setup(lights) {
        let r = 0, g = 0, b = 0;
        for(let i = 0; i < 9; i++)state.probe[i].set(0, 0, 0);
        let directionalLength = 0;
        let pointLength = 0;
        let spotLength = 0;
        let rectAreaLength = 0;
        let hemiLength = 0;
        let numDirectionalShadows = 0;
        let numPointShadows = 0;
        let numSpotShadows = 0;
        let numSpotMaps = 0;
        let numSpotShadowsWithMaps = 0;
        let numLightProbes = 0;
        // ordering : [shadow casting + map texturing, map texturing, shadow casting, none ]
        lights.sort($3dd44ec8564e7230$var$shadowCastingAndTexturingLightsFirst);
        for(let i = 0, l = lights.length; i < l; i++){
            const light = lights[i];
            const color = light.color;
            const intensity = light.intensity;
            const distance = light.distance;
            const shadowMap = light.shadow && light.shadow.map ? light.shadow.map.texture : null;
            if (light.isAmbientLight) {
                r += color.r * intensity;
                g += color.g * intensity;
                b += color.b * intensity;
            } else if (light.isLightProbe) {
                for(let j = 0; j < 9; j++)state.probe[j].addScaledVector(light.sh.coefficients[j], intensity);
                numLightProbes++;
            } else if (light.isDirectionalLight) {
                const uniforms = cache.get(light);
                uniforms.color.copy(light.color).multiplyScalar(light.intensity);
                if (light.castShadow) {
                    const shadow = light.shadow;
                    const shadowUniforms = shadowCache.get(light);
                    shadowUniforms.shadowIntensity = shadow.intensity;
                    shadowUniforms.shadowBias = shadow.bias;
                    shadowUniforms.shadowNormalBias = shadow.normalBias;
                    shadowUniforms.shadowRadius = shadow.radius;
                    shadowUniforms.shadowMapSize = shadow.mapSize;
                    state.directionalShadow[directionalLength] = shadowUniforms;
                    state.directionalShadowMap[directionalLength] = shadowMap;
                    state.directionalShadowMatrix[directionalLength] = light.shadow.matrix;
                    numDirectionalShadows++;
                }
                state.directional[directionalLength] = uniforms;
                directionalLength++;
            } else if (light.isSpotLight) {
                const uniforms = cache.get(light);
                uniforms.position.setFromMatrixPosition(light.matrixWorld);
                uniforms.color.copy(color).multiplyScalar(intensity);
                uniforms.distance = distance;
                uniforms.coneCos = Math.cos(light.angle);
                uniforms.penumbraCos = Math.cos(light.angle * (1 - light.penumbra));
                uniforms.decay = light.decay;
                state.spot[spotLength] = uniforms;
                const shadow = light.shadow;
                if (light.map) {
                    state.spotLightMap[numSpotMaps] = light.map;
                    numSpotMaps++;
                    // make sure the lightMatrix is up to date
                    // TODO : do it if required only
                    shadow.updateMatrices(light);
                    if (light.castShadow) numSpotShadowsWithMaps++;
                }
                state.spotLightMatrix[spotLength] = shadow.matrix;
                if (light.castShadow) {
                    const shadowUniforms = shadowCache.get(light);
                    shadowUniforms.shadowIntensity = shadow.intensity;
                    shadowUniforms.shadowBias = shadow.bias;
                    shadowUniforms.shadowNormalBias = shadow.normalBias;
                    shadowUniforms.shadowRadius = shadow.radius;
                    shadowUniforms.shadowMapSize = shadow.mapSize;
                    state.spotShadow[spotLength] = shadowUniforms;
                    state.spotShadowMap[spotLength] = shadowMap;
                    numSpotShadows++;
                }
                spotLength++;
            } else if (light.isRectAreaLight) {
                const uniforms = cache.get(light);
                uniforms.color.copy(color).multiplyScalar(intensity);
                uniforms.halfWidth.set(light.width * 0.5, 0.0, 0.0);
                uniforms.halfHeight.set(0.0, light.height * 0.5, 0.0);
                state.rectArea[rectAreaLength] = uniforms;
                rectAreaLength++;
            } else if (light.isPointLight) {
                const uniforms = cache.get(light);
                uniforms.color.copy(light.color).multiplyScalar(light.intensity);
                uniforms.distance = light.distance;
                uniforms.decay = light.decay;
                if (light.castShadow) {
                    const shadow = light.shadow;
                    const shadowUniforms = shadowCache.get(light);
                    shadowUniforms.shadowIntensity = shadow.intensity;
                    shadowUniforms.shadowBias = shadow.bias;
                    shadowUniforms.shadowNormalBias = shadow.normalBias;
                    shadowUniforms.shadowRadius = shadow.radius;
                    shadowUniforms.shadowMapSize = shadow.mapSize;
                    shadowUniforms.shadowCameraNear = shadow.camera.near;
                    shadowUniforms.shadowCameraFar = shadow.camera.far;
                    state.pointShadow[pointLength] = shadowUniforms;
                    state.pointShadowMap[pointLength] = shadowMap;
                    state.pointShadowMatrix[pointLength] = light.shadow.matrix;
                    numPointShadows++;
                }
                state.point[pointLength] = uniforms;
                pointLength++;
            } else if (light.isHemisphereLight) {
                const uniforms = cache.get(light);
                uniforms.skyColor.copy(light.color).multiplyScalar(intensity);
                uniforms.groundColor.copy(light.groundColor).multiplyScalar(intensity);
                state.hemi[hemiLength] = uniforms;
                hemiLength++;
            }
        }
        if (rectAreaLength > 0) {
            if (extensions.has('OES_texture_float_linear') === true) {
                state.rectAreaLTC1 = $3dd44ec8564e7230$export$6643083551874bf5.LTC_FLOAT_1;
                state.rectAreaLTC2 = $3dd44ec8564e7230$export$6643083551874bf5.LTC_FLOAT_2;
            } else {
                state.rectAreaLTC1 = $3dd44ec8564e7230$export$6643083551874bf5.LTC_HALF_1;
                state.rectAreaLTC2 = $3dd44ec8564e7230$export$6643083551874bf5.LTC_HALF_2;
            }
        }
        state.ambient[0] = r;
        state.ambient[1] = g;
        state.ambient[2] = b;
        const hash = state.hash;
        if (hash.directionalLength !== directionalLength || hash.pointLength !== pointLength || hash.spotLength !== spotLength || hash.rectAreaLength !== rectAreaLength || hash.hemiLength !== hemiLength || hash.numDirectionalShadows !== numDirectionalShadows || hash.numPointShadows !== numPointShadows || hash.numSpotShadows !== numSpotShadows || hash.numSpotMaps !== numSpotMaps || hash.numLightProbes !== numLightProbes) {
            state.directional.length = directionalLength;
            state.spot.length = spotLength;
            state.rectArea.length = rectAreaLength;
            state.point.length = pointLength;
            state.hemi.length = hemiLength;
            state.directionalShadow.length = numDirectionalShadows;
            state.directionalShadowMap.length = numDirectionalShadows;
            state.pointShadow.length = numPointShadows;
            state.pointShadowMap.length = numPointShadows;
            state.spotShadow.length = numSpotShadows;
            state.spotShadowMap.length = numSpotShadows;
            state.directionalShadowMatrix.length = numDirectionalShadows;
            state.pointShadowMatrix.length = numPointShadows;
            state.spotLightMatrix.length = numSpotShadows + numSpotMaps - numSpotShadowsWithMaps;
            state.spotLightMap.length = numSpotMaps;
            state.numSpotLightShadowsWithMaps = numSpotShadowsWithMaps;
            state.numLightProbes = numLightProbes;
            hash.directionalLength = directionalLength;
            hash.pointLength = pointLength;
            hash.spotLength = spotLength;
            hash.rectAreaLength = rectAreaLength;
            hash.hemiLength = hemiLength;
            hash.numDirectionalShadows = numDirectionalShadows;
            hash.numPointShadows = numPointShadows;
            hash.numSpotShadows = numSpotShadows;
            hash.numSpotMaps = numSpotMaps;
            hash.numLightProbes = numLightProbes;
            state.version = $3dd44ec8564e7230$var$nextVersion++;
        }
    }
    function setupView(lights, camera) {
        let directionalLength = 0;
        let pointLength = 0;
        let spotLength = 0;
        let rectAreaLength = 0;
        let hemiLength = 0;
        const viewMatrix = camera.matrixWorldInverse;
        for(let i = 0, l = lights.length; i < l; i++){
            const light = lights[i];
            if (light.isDirectionalLight) {
                const uniforms = state.directional[directionalLength];
                uniforms.direction.setFromMatrixPosition(light.matrixWorld);
                vector3.setFromMatrixPosition(light.target.matrixWorld);
                uniforms.direction.sub(vector3);
                uniforms.direction.transformDirection(viewMatrix);
                directionalLength++;
            } else if (light.isSpotLight) {
                const uniforms = state.spot[spotLength];
                uniforms.position.setFromMatrixPosition(light.matrixWorld);
                uniforms.position.applyMatrix4(viewMatrix);
                uniforms.direction.setFromMatrixPosition(light.matrixWorld);
                vector3.setFromMatrixPosition(light.target.matrixWorld);
                uniforms.direction.sub(vector3);
                uniforms.direction.transformDirection(viewMatrix);
                spotLength++;
            } else if (light.isRectAreaLight) {
                const uniforms = state.rectArea[rectAreaLength];
                uniforms.position.setFromMatrixPosition(light.matrixWorld);
                uniforms.position.applyMatrix4(viewMatrix);
                // extract local rotation of light to derive width/height half vectors
                matrix42.identity();
                matrix4.copy(light.matrixWorld);
                matrix4.premultiply(viewMatrix);
                matrix42.extractRotation(matrix4);
                uniforms.halfWidth.set(light.width * 0.5, 0.0, 0.0);
                uniforms.halfHeight.set(0.0, light.height * 0.5, 0.0);
                uniforms.halfWidth.applyMatrix4(matrix42);
                uniforms.halfHeight.applyMatrix4(matrix42);
                rectAreaLength++;
            } else if (light.isPointLight) {
                const uniforms = state.point[pointLength];
                uniforms.position.setFromMatrixPosition(light.matrixWorld);
                uniforms.position.applyMatrix4(viewMatrix);
                pointLength++;
            } else if (light.isHemisphereLight) {
                const uniforms = state.hemi[hemiLength];
                uniforms.direction.setFromMatrixPosition(light.matrixWorld);
                uniforms.direction.transformDirection(viewMatrix);
                hemiLength++;
            }
        }
    }
    return {
        setup: setup,
        setupView: setupView,
        state: state
    };
}
function $3dd44ec8564e7230$var$WebGLRenderState(extensions) {
    const lights = new $3dd44ec8564e7230$var$WebGLLights(extensions);
    const lightsArray = [];
    const shadowsArray = [];
    function init(camera) {
        state.camera = camera;
        lightsArray.length = 0;
        shadowsArray.length = 0;
    }
    function pushLight(light) {
        lightsArray.push(light);
    }
    function pushShadow(shadowLight) {
        shadowsArray.push(shadowLight);
    }
    function setupLights() {
        lights.setup(lightsArray);
    }
    function setupLightsView(camera) {
        lights.setupView(lightsArray, camera);
    }
    const state = {
        lightsArray: lightsArray,
        shadowsArray: shadowsArray,
        camera: null,
        lights: lights,
        transmissionRenderTarget: {}
    };
    return {
        init: init,
        state: state,
        setupLights: setupLights,
        setupLightsView: setupLightsView,
        pushLight: pushLight,
        pushShadow: pushShadow
    };
}
function $3dd44ec8564e7230$var$WebGLRenderStates(extensions) {
    let renderStates = new WeakMap();
    function get(scene, renderCallDepth = 0) {
        const renderStateArray = renderStates.get(scene);
        let renderState;
        if (renderStateArray === undefined) {
            renderState = new $3dd44ec8564e7230$var$WebGLRenderState(extensions);
            renderStates.set(scene, [
                renderState
            ]);
        } else if (renderCallDepth >= renderStateArray.length) {
            renderState = new $3dd44ec8564e7230$var$WebGLRenderState(extensions);
            renderStateArray.push(renderState);
        } else renderState = renderStateArray[renderCallDepth];
        return renderState;
    }
    function dispose() {
        renderStates = new WeakMap();
    }
    return {
        get: get,
        dispose: dispose
    };
}
const $3dd44ec8564e7230$var$vertex = "void main() {\n\tgl_Position = vec4( position, 1.0 );\n}";
const $3dd44ec8564e7230$var$fragment = "uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tconst float samples = float( VSM_SAMPLES );\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat uvStride = samples <= 1.0 ? 0.0 : 2.0 / ( samples - 1.0 );\n\tfloat uvStart = samples <= 1.0 ? 0.0 : - 1.0;\n\tfor ( float i = 0.0; i < samples; i ++ ) {\n\t\tfloat uvOffset = uvStart + i * uvStride;\n\t\t#ifdef HORIZONTAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( uvOffset, 0.0 ) * radius ) / resolution ) );\n\t\t\tmean += distribution.x;\n\t\t\tsquared_mean += distribution.y * distribution.y + distribution.x * distribution.x;\n\t\t#else\n\t\t\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( 0.0, uvOffset ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean / samples;\n\tsquared_mean = squared_mean / samples;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}";
function $3dd44ec8564e7230$var$WebGLShadowMap(renderer, objects, capabilities) {
    let _frustum = new (0, $d5b85d29c0b78636$export$35efe6f4c85463d2)();
    const _shadowMapSize = new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(), _viewportSize = new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(), _viewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)(), _depthMaterial = new (0, $d5b85d29c0b78636$export$2698c22ec13825db)({
        depthPacking: (0, $d5b85d29c0b78636$export$8f910f4c4f73df11)
    }), _distanceMaterial = new (0, $d5b85d29c0b78636$export$33e187ed002f2a19)(), _materialCache = {}, _maxTextureSize = capabilities.maxTextureSize;
    const shadowSide = {
        [(0, $d5b85d29c0b78636$export$2ede184fc2998901)]: (0, $d5b85d29c0b78636$export$d9f0486e75b5ace),
        [(0, $d5b85d29c0b78636$export$d9f0486e75b5ace)]: (0, $d5b85d29c0b78636$export$2ede184fc2998901),
        [(0, $d5b85d29c0b78636$export$3b296b6f144d5b03)]: (0, $d5b85d29c0b78636$export$3b296b6f144d5b03)
    };
    const shadowMaterialVertical = new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
        defines: {
            VSM_SAMPLES: 8
        },
        uniforms: {
            shadow_pass: {
                value: null
            },
            resolution: {
                value: new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)()
            },
            radius: {
                value: 4.0
            }
        },
        vertexShader: $3dd44ec8564e7230$var$vertex,
        fragmentShader: $3dd44ec8564e7230$var$fragment
    });
    const shadowMaterialHorizontal = shadowMaterialVertical.clone();
    shadowMaterialHorizontal.defines.HORIZONTAL_PASS = 1;
    const fullScreenTri = new (0, $d5b85d29c0b78636$export$b7be63a67df8959)();
    fullScreenTri.setAttribute('position', new (0, $d5b85d29c0b78636$export$8dea267bd6bde117)(new Float32Array([
        -1,
        -1,
        0.5,
        3,
        -1,
        0.5,
        -1,
        3,
        0.5
    ]), 3));
    const fullScreenMesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(fullScreenTri, shadowMaterialVertical);
    const scope = this;
    this.enabled = false;
    this.autoUpdate = true;
    this.needsUpdate = false;
    this.type = (0, $d5b85d29c0b78636$export$5813f879eee7cd88);
    let _previousType = this.type;
    this.render = function(lights, scene, camera) {
        if (scope.enabled === false) return;
        if (scope.autoUpdate === false && scope.needsUpdate === false) return;
        if (lights.length === 0) return;
        const currentRenderTarget = renderer.getRenderTarget();
        const activeCubeFace = renderer.getActiveCubeFace();
        const activeMipmapLevel = renderer.getActiveMipmapLevel();
        const _state = renderer.state;
        // Set GL state for depth map.
        _state.setBlending((0, $d5b85d29c0b78636$export$63b8d6b580fc65ba));
        _state.buffers.color.setClear(1, 1, 1, 1);
        _state.buffers.depth.setTest(true);
        _state.setScissorTest(false);
        // check for shadow map type changes
        const toVSM = _previousType !== (0, $d5b85d29c0b78636$export$896ae1ade6c829c4) && this.type === (0, $d5b85d29c0b78636$export$896ae1ade6c829c4);
        const fromVSM = _previousType === (0, $d5b85d29c0b78636$export$896ae1ade6c829c4) && this.type !== (0, $d5b85d29c0b78636$export$896ae1ade6c829c4);
        // render depth map
        for(let i = 0, il = lights.length; i < il; i++){
            const light = lights[i];
            const shadow = light.shadow;
            if (shadow === undefined) {
                console.warn('THREE.WebGLShadowMap:', light, 'has no shadow.');
                continue;
            }
            if (shadow.autoUpdate === false && shadow.needsUpdate === false) continue;
            _shadowMapSize.copy(shadow.mapSize);
            const shadowFrameExtents = shadow.getFrameExtents();
            _shadowMapSize.multiply(shadowFrameExtents);
            _viewportSize.copy(shadow.mapSize);
            if (_shadowMapSize.x > _maxTextureSize || _shadowMapSize.y > _maxTextureSize) {
                if (_shadowMapSize.x > _maxTextureSize) {
                    _viewportSize.x = Math.floor(_maxTextureSize / shadowFrameExtents.x);
                    _shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x;
                    shadow.mapSize.x = _viewportSize.x;
                }
                if (_shadowMapSize.y > _maxTextureSize) {
                    _viewportSize.y = Math.floor(_maxTextureSize / shadowFrameExtents.y);
                    _shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y;
                    shadow.mapSize.y = _viewportSize.y;
                }
            }
            if (shadow.map === null || toVSM === true || fromVSM === true) {
                const pars = this.type !== (0, $d5b85d29c0b78636$export$896ae1ade6c829c4) ? {
                    minFilter: (0, $d5b85d29c0b78636$export$727aa5ec3fe39bf0),
                    magFilter: (0, $d5b85d29c0b78636$export$727aa5ec3fe39bf0)
                } : {};
                if (shadow.map !== null) shadow.map.dispose();
                shadow.map = new (0, $d5b85d29c0b78636$export$3c052beb2e51e23f)(_shadowMapSize.x, _shadowMapSize.y, pars);
                shadow.map.texture.name = light.name + '.shadowMap';
                shadow.camera.updateProjectionMatrix();
            }
            renderer.setRenderTarget(shadow.map);
            renderer.clear();
            const viewportCount = shadow.getViewportCount();
            for(let vp = 0; vp < viewportCount; vp++){
                const viewport = shadow.getViewport(vp);
                _viewport.set(_viewportSize.x * viewport.x, _viewportSize.y * viewport.y, _viewportSize.x * viewport.z, _viewportSize.y * viewport.w);
                _state.viewport(_viewport);
                shadow.updateMatrices(light, vp);
                _frustum = shadow.getFrustum();
                renderObject(scene, camera, shadow.camera, light, this.type);
            }
            // do blur pass for VSM
            if (shadow.isPointLightShadow !== true && this.type === (0, $d5b85d29c0b78636$export$896ae1ade6c829c4)) VSMPass(shadow, camera);
            shadow.needsUpdate = false;
        }
        _previousType = this.type;
        scope.needsUpdate = false;
        renderer.setRenderTarget(currentRenderTarget, activeCubeFace, activeMipmapLevel);
    };
    function VSMPass(shadow, camera) {
        const geometry = objects.update(fullScreenMesh);
        if (shadowMaterialVertical.defines.VSM_SAMPLES !== shadow.blurSamples) {
            shadowMaterialVertical.defines.VSM_SAMPLES = shadow.blurSamples;
            shadowMaterialHorizontal.defines.VSM_SAMPLES = shadow.blurSamples;
            shadowMaterialVertical.needsUpdate = true;
            shadowMaterialHorizontal.needsUpdate = true;
        }
        if (shadow.mapPass === null) shadow.mapPass = new (0, $d5b85d29c0b78636$export$3c052beb2e51e23f)(_shadowMapSize.x, _shadowMapSize.y);
        // vertical pass
        shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture;
        shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize;
        shadowMaterialVertical.uniforms.radius.value = shadow.radius;
        renderer.setRenderTarget(shadow.mapPass);
        renderer.clear();
        renderer.renderBufferDirect(camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null);
        // horizontal pass
        shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture;
        shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize;
        shadowMaterialHorizontal.uniforms.radius.value = shadow.radius;
        renderer.setRenderTarget(shadow.map);
        renderer.clear();
        renderer.renderBufferDirect(camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null);
    }
    function getDepthMaterial(object, material, light, type) {
        let result = null;
        const customMaterial = light.isPointLight === true ? object.customDistanceMaterial : object.customDepthMaterial;
        if (customMaterial !== undefined) result = customMaterial;
        else {
            result = light.isPointLight === true ? _distanceMaterial : _depthMaterial;
            if (renderer.localClippingEnabled && material.clipShadows === true && Array.isArray(material.clippingPlanes) && material.clippingPlanes.length !== 0 || material.displacementMap && material.displacementScale !== 0 || material.alphaMap && material.alphaTest > 0 || material.map && material.alphaTest > 0) {
                // in this case we need a unique material instance reflecting the
                // appropriate state
                const keyA = result.uuid, keyB = material.uuid;
                let materialsForVariant = _materialCache[keyA];
                if (materialsForVariant === undefined) {
                    materialsForVariant = {};
                    _materialCache[keyA] = materialsForVariant;
                }
                let cachedMaterial = materialsForVariant[keyB];
                if (cachedMaterial === undefined) {
                    cachedMaterial = result.clone();
                    materialsForVariant[keyB] = cachedMaterial;
                    material.addEventListener('dispose', onMaterialDispose);
                }
                result = cachedMaterial;
            }
        }
        result.visible = material.visible;
        result.wireframe = material.wireframe;
        if (type === (0, $d5b85d29c0b78636$export$896ae1ade6c829c4)) result.side = material.shadowSide !== null ? material.shadowSide : material.side;
        else result.side = material.shadowSide !== null ? material.shadowSide : shadowSide[material.side];
        result.alphaMap = material.alphaMap;
        result.alphaTest = material.alphaTest;
        result.map = material.map;
        result.clipShadows = material.clipShadows;
        result.clippingPlanes = material.clippingPlanes;
        result.clipIntersection = material.clipIntersection;
        result.displacementMap = material.displacementMap;
        result.displacementScale = material.displacementScale;
        result.displacementBias = material.displacementBias;
        result.wireframeLinewidth = material.wireframeLinewidth;
        result.linewidth = material.linewidth;
        if (light.isPointLight === true && result.isMeshDistanceMaterial === true) {
            const materialProperties = renderer.properties.get(result);
            materialProperties.light = light;
        }
        return result;
    }
    function renderObject(object, camera, shadowCamera, light, type) {
        if (object.visible === false) return;
        const visible = object.layers.test(camera.layers);
        if (visible && (object.isMesh || object.isLine || object.isPoints)) {
            if ((object.castShadow || object.receiveShadow && type === (0, $d5b85d29c0b78636$export$896ae1ade6c829c4)) && (!object.frustumCulled || _frustum.intersectsObject(object))) {
                object.modelViewMatrix.multiplyMatrices(shadowCamera.matrixWorldInverse, object.matrixWorld);
                const geometry = objects.update(object);
                const material = object.material;
                if (Array.isArray(material)) {
                    const groups = geometry.groups;
                    for(let k = 0, kl = groups.length; k < kl; k++){
                        const group = groups[k];
                        const groupMaterial = material[group.materialIndex];
                        if (groupMaterial && groupMaterial.visible) {
                            const depthMaterial = getDepthMaterial(object, groupMaterial, light, type);
                            object.onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, group);
                            renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group);
                            object.onAfterShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, group);
                        }
                    }
                } else if (material.visible) {
                    const depthMaterial = getDepthMaterial(object, material, light, type);
                    object.onBeforeShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, null);
                    renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null);
                    object.onAfterShadow(renderer, object, camera, shadowCamera, geometry, depthMaterial, null);
                }
            }
        }
        const children = object.children;
        for(let i = 0, l = children.length; i < l; i++)renderObject(children[i], camera, shadowCamera, light, type);
    }
    function onMaterialDispose(event) {
        const material = event.target;
        material.removeEventListener('dispose', onMaterialDispose);
        // make sure to remove the unique distance/depth materials used for shadow map rendering
        for(const id in _materialCache){
            const cache = _materialCache[id];
            const uuid = event.target.uuid;
            if (uuid in cache) {
                const shadowMaterial = cache[uuid];
                shadowMaterial.dispose();
                delete cache[uuid];
            }
        }
    }
}
const $3dd44ec8564e7230$var$reversedFuncs = {
    [(0, $d5b85d29c0b78636$export$69025ce147cee220)]: (0, $d5b85d29c0b78636$export$7182eb52ea3b3f04),
    [(0, $d5b85d29c0b78636$export$eedccec66ab7ebe)]: (0, $d5b85d29c0b78636$export$c5e2c52991f30937),
    [(0, $d5b85d29c0b78636$export$a60d398fc7b7590e)]: (0, $d5b85d29c0b78636$export$2f843afa843d8916),
    [(0, $d5b85d29c0b78636$export$296f78a0b892f81a)]: (0, $d5b85d29c0b78636$export$7d7234c1240a1fc4),
    [(0, $d5b85d29c0b78636$export$7182eb52ea3b3f04)]: (0, $d5b85d29c0b78636$export$69025ce147cee220),
    [(0, $d5b85d29c0b78636$export$c5e2c52991f30937)]: (0, $d5b85d29c0b78636$export$eedccec66ab7ebe),
    [(0, $d5b85d29c0b78636$export$2f843afa843d8916)]: (0, $d5b85d29c0b78636$export$a60d398fc7b7590e),
    [(0, $d5b85d29c0b78636$export$7d7234c1240a1fc4)]: (0, $d5b85d29c0b78636$export$296f78a0b892f81a)
};
function $3dd44ec8564e7230$var$WebGLState(gl, extensions) {
    function ColorBuffer() {
        let locked = false;
        const color = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
        let currentColorMask = null;
        const currentColorClear = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)(0, 0, 0, 0);
        return {
            setMask: function(colorMask) {
                if (currentColorMask !== colorMask && !locked) {
                    gl.colorMask(colorMask, colorMask, colorMask, colorMask);
                    currentColorMask = colorMask;
                }
            },
            setLocked: function(lock) {
                locked = lock;
            },
            setClear: function(r, g, b, a, premultipliedAlpha) {
                if (premultipliedAlpha === true) {
                    r *= a;
                    g *= a;
                    b *= a;
                }
                color.set(r, g, b, a);
                if (currentColorClear.equals(color) === false) {
                    gl.clearColor(r, g, b, a);
                    currentColorClear.copy(color);
                }
            },
            reset: function() {
                locked = false;
                currentColorMask = null;
                currentColorClear.set(-1, 0, 0, 0); // set to invalid state
            }
        };
    }
    function DepthBuffer() {
        let locked = false;
        let reversed = false;
        let currentDepthMask = null;
        let currentDepthFunc = null;
        let currentDepthClear = null;
        return {
            setReversed: function(value) {
                if (reversed !== value) {
                    const ext = extensions.get('EXT_clip_control');
                    if (reversed) ext.clipControlEXT(ext.LOWER_LEFT_EXT, ext.ZERO_TO_ONE_EXT);
                    else ext.clipControlEXT(ext.LOWER_LEFT_EXT, ext.NEGATIVE_ONE_TO_ONE_EXT);
                    const oldDepth = currentDepthClear;
                    currentDepthClear = null;
                    this.setClear(oldDepth);
                }
                reversed = value;
            },
            getReversed: function() {
                return reversed;
            },
            setTest: function(depthTest) {
                if (depthTest) enable(gl.DEPTH_TEST);
                else disable(gl.DEPTH_TEST);
            },
            setMask: function(depthMask) {
                if (currentDepthMask !== depthMask && !locked) {
                    gl.depthMask(depthMask);
                    currentDepthMask = depthMask;
                }
            },
            setFunc: function(depthFunc) {
                if (reversed) depthFunc = $3dd44ec8564e7230$var$reversedFuncs[depthFunc];
                if (currentDepthFunc !== depthFunc) {
                    switch(depthFunc){
                        case 0, $d5b85d29c0b78636$export$69025ce147cee220:
                            gl.depthFunc(gl.NEVER);
                            break;
                        case 0, $d5b85d29c0b78636$export$7182eb52ea3b3f04:
                            gl.depthFunc(gl.ALWAYS);
                            break;
                        case 0, $d5b85d29c0b78636$export$eedccec66ab7ebe:
                            gl.depthFunc(gl.LESS);
                            break;
                        case 0, $d5b85d29c0b78636$export$296f78a0b892f81a:
                            gl.depthFunc(gl.LEQUAL);
                            break;
                        case 0, $d5b85d29c0b78636$export$a60d398fc7b7590e:
                            gl.depthFunc(gl.EQUAL);
                            break;
                        case 0, $d5b85d29c0b78636$export$7d7234c1240a1fc4:
                            gl.depthFunc(gl.GEQUAL);
                            break;
                        case 0, $d5b85d29c0b78636$export$c5e2c52991f30937:
                            gl.depthFunc(gl.GREATER);
                            break;
                        case 0, $d5b85d29c0b78636$export$2f843afa843d8916:
                            gl.depthFunc(gl.NOTEQUAL);
                            break;
                        default:
                            gl.depthFunc(gl.LEQUAL);
                    }
                    currentDepthFunc = depthFunc;
                }
            },
            setLocked: function(lock) {
                locked = lock;
            },
            setClear: function(depth) {
                if (currentDepthClear !== depth) {
                    if (reversed) depth = 1 - depth;
                    gl.clearDepth(depth);
                    currentDepthClear = depth;
                }
            },
            reset: function() {
                locked = false;
                currentDepthMask = null;
                currentDepthFunc = null;
                currentDepthClear = null;
                reversed = false;
            }
        };
    }
    function StencilBuffer() {
        let locked = false;
        let currentStencilMask = null;
        let currentStencilFunc = null;
        let currentStencilRef = null;
        let currentStencilFuncMask = null;
        let currentStencilFail = null;
        let currentStencilZFail = null;
        let currentStencilZPass = null;
        let currentStencilClear = null;
        return {
            setTest: function(stencilTest) {
                if (!locked) {
                    if (stencilTest) enable(gl.STENCIL_TEST);
                    else disable(gl.STENCIL_TEST);
                }
            },
            setMask: function(stencilMask) {
                if (currentStencilMask !== stencilMask && !locked) {
                    gl.stencilMask(stencilMask);
                    currentStencilMask = stencilMask;
                }
            },
            setFunc: function(stencilFunc, stencilRef, stencilMask) {
                if (currentStencilFunc !== stencilFunc || currentStencilRef !== stencilRef || currentStencilFuncMask !== stencilMask) {
                    gl.stencilFunc(stencilFunc, stencilRef, stencilMask);
                    currentStencilFunc = stencilFunc;
                    currentStencilRef = stencilRef;
                    currentStencilFuncMask = stencilMask;
                }
            },
            setOp: function(stencilFail, stencilZFail, stencilZPass) {
                if (currentStencilFail !== stencilFail || currentStencilZFail !== stencilZFail || currentStencilZPass !== stencilZPass) {
                    gl.stencilOp(stencilFail, stencilZFail, stencilZPass);
                    currentStencilFail = stencilFail;
                    currentStencilZFail = stencilZFail;
                    currentStencilZPass = stencilZPass;
                }
            },
            setLocked: function(lock) {
                locked = lock;
            },
            setClear: function(stencil) {
                if (currentStencilClear !== stencil) {
                    gl.clearStencil(stencil);
                    currentStencilClear = stencil;
                }
            },
            reset: function() {
                locked = false;
                currentStencilMask = null;
                currentStencilFunc = null;
                currentStencilRef = null;
                currentStencilFuncMask = null;
                currentStencilFail = null;
                currentStencilZFail = null;
                currentStencilZPass = null;
                currentStencilClear = null;
            }
        };
    }
    //
    const colorBuffer = new ColorBuffer();
    const depthBuffer = new DepthBuffer();
    const stencilBuffer = new StencilBuffer();
    const uboBindings = new WeakMap();
    const uboProgramMap = new WeakMap();
    let enabledCapabilities = {};
    let currentBoundFramebuffers = {};
    let currentDrawbuffers = new WeakMap();
    let defaultDrawbuffers = [];
    let currentProgram = null;
    let currentBlendingEnabled = false;
    let currentBlending = null;
    let currentBlendEquation = null;
    let currentBlendSrc = null;
    let currentBlendDst = null;
    let currentBlendEquationAlpha = null;
    let currentBlendSrcAlpha = null;
    let currentBlendDstAlpha = null;
    let currentBlendColor = new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0, 0, 0);
    let currentBlendAlpha = 0;
    let currentPremultipledAlpha = false;
    let currentFlipSided = null;
    let currentCullFace = null;
    let currentLineWidth = null;
    let currentPolygonOffsetFactor = null;
    let currentPolygonOffsetUnits = null;
    const maxTextures = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
    let lineWidthAvailable = false;
    let version = 0;
    const glVersion = gl.getParameter(gl.VERSION);
    if (glVersion.indexOf('WebGL') !== -1) {
        version = parseFloat(/^WebGL (\d)/.exec(glVersion)[1]);
        lineWidthAvailable = version >= 1.0;
    } else if (glVersion.indexOf('OpenGL ES') !== -1) {
        version = parseFloat(/^OpenGL ES (\d)/.exec(glVersion)[1]);
        lineWidthAvailable = version >= 2.0;
    }
    let currentTextureSlot = null;
    let currentBoundTextures = {};
    const scissorParam = gl.getParameter(gl.SCISSOR_BOX);
    const viewportParam = gl.getParameter(gl.VIEWPORT);
    const currentScissor = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)().fromArray(scissorParam);
    const currentViewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)().fromArray(viewportParam);
    function createTexture(type, target, count, dimensions) {
        const data = new Uint8Array(4); // 4 is required to match default unpack alignment of 4.
        const texture = gl.createTexture();
        gl.bindTexture(type, texture);
        gl.texParameteri(type, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
        gl.texParameteri(type, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
        for(let i = 0; i < count; i++)if (type === gl.TEXTURE_3D || type === gl.TEXTURE_2D_ARRAY) gl.texImage3D(target, 0, gl.RGBA, 1, 1, dimensions, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
        else gl.texImage2D(target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
        return texture;
    }
    const emptyTextures = {};
    emptyTextures[gl.TEXTURE_2D] = createTexture(gl.TEXTURE_2D, gl.TEXTURE_2D, 1);
    emptyTextures[gl.TEXTURE_CUBE_MAP] = createTexture(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6);
    emptyTextures[gl.TEXTURE_2D_ARRAY] = createTexture(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_2D_ARRAY, 1, 1);
    emptyTextures[gl.TEXTURE_3D] = createTexture(gl.TEXTURE_3D, gl.TEXTURE_3D, 1, 1);
    // init
    colorBuffer.setClear(0, 0, 0, 1);
    depthBuffer.setClear(1);
    stencilBuffer.setClear(0);
    enable(gl.DEPTH_TEST);
    depthBuffer.setFunc((0, $d5b85d29c0b78636$export$296f78a0b892f81a));
    setFlipSided(false);
    setCullFace((0, $d5b85d29c0b78636$export$b9a7b4fc5cb15f9b));
    enable(gl.CULL_FACE);
    setBlending((0, $d5b85d29c0b78636$export$63b8d6b580fc65ba));
    //
    function enable(id) {
        if (enabledCapabilities[id] !== true) {
            gl.enable(id);
            enabledCapabilities[id] = true;
        }
    }
    function disable(id) {
        if (enabledCapabilities[id] !== false) {
            gl.disable(id);
            enabledCapabilities[id] = false;
        }
    }
    function bindFramebuffer(target, framebuffer) {
        if (currentBoundFramebuffers[target] !== framebuffer) {
            gl.bindFramebuffer(target, framebuffer);
            currentBoundFramebuffers[target] = framebuffer;
            // gl.DRAW_FRAMEBUFFER is equivalent to gl.FRAMEBUFFER
            if (target === gl.DRAW_FRAMEBUFFER) currentBoundFramebuffers[gl.FRAMEBUFFER] = framebuffer;
            if (target === gl.FRAMEBUFFER) currentBoundFramebuffers[gl.DRAW_FRAMEBUFFER] = framebuffer;
            return true;
        }
        return false;
    }
    function drawBuffers(renderTarget, framebuffer) {
        let drawBuffers = defaultDrawbuffers;
        let needsUpdate = false;
        if (renderTarget) {
            drawBuffers = currentDrawbuffers.get(framebuffer);
            if (drawBuffers === undefined) {
                drawBuffers = [];
                currentDrawbuffers.set(framebuffer, drawBuffers);
            }
            const textures = renderTarget.textures;
            if (drawBuffers.length !== textures.length || drawBuffers[0] !== gl.COLOR_ATTACHMENT0) {
                for(let i = 0, il = textures.length; i < il; i++)drawBuffers[i] = gl.COLOR_ATTACHMENT0 + i;
                drawBuffers.length = textures.length;
                needsUpdate = true;
            }
        } else if (drawBuffers[0] !== gl.BACK) {
            drawBuffers[0] = gl.BACK;
            needsUpdate = true;
        }
        if (needsUpdate) gl.drawBuffers(drawBuffers);
    }
    function useProgram(program) {
        if (currentProgram !== program) {
            gl.useProgram(program);
            currentProgram = program;
            return true;
        }
        return false;
    }
    const equationToGL = {
        [(0, $d5b85d29c0b78636$export$20183a0484ce21a0)]: gl.FUNC_ADD,
        [(0, $d5b85d29c0b78636$export$73e0df5177988548)]: gl.FUNC_SUBTRACT,
        [(0, $d5b85d29c0b78636$export$28e582859cbec660)]: gl.FUNC_REVERSE_SUBTRACT
    };
    equationToGL[0, $d5b85d29c0b78636$export$c8c1508da8d0600c] = gl.MIN;
    equationToGL[0, $d5b85d29c0b78636$export$99948c02fb51055f] = gl.MAX;
    const factorToGL = {
        [(0, $d5b85d29c0b78636$export$2110f05edf778d3d)]: gl.ZERO,
        [(0, $d5b85d29c0b78636$export$8805bad65e24940e)]: gl.ONE,
        [(0, $d5b85d29c0b78636$export$7fbe15b28d28cf52)]: gl.SRC_COLOR,
        [(0, $d5b85d29c0b78636$export$d5773124e86cf28c)]: gl.SRC_ALPHA,
        [(0, $d5b85d29c0b78636$export$c05e2a1fc8609506)]: gl.SRC_ALPHA_SATURATE,
        [(0, $d5b85d29c0b78636$export$ef5f2dd8ffac5574)]: gl.DST_COLOR,
        [(0, $d5b85d29c0b78636$export$a78aed1ca2a87192)]: gl.DST_ALPHA,
        [(0, $d5b85d29c0b78636$export$947829af9f2c17f6)]: gl.ONE_MINUS_SRC_COLOR,
        [(0, $d5b85d29c0b78636$export$11d468cc7f19e971)]: gl.ONE_MINUS_SRC_ALPHA,
        [(0, $d5b85d29c0b78636$export$56b85b2686ab16)]: gl.ONE_MINUS_DST_COLOR,
        [(0, $d5b85d29c0b78636$export$5d0fe17fd8773bac)]: gl.ONE_MINUS_DST_ALPHA,
        [(0, $d5b85d29c0b78636$export$7dd8f434fd59075)]: gl.CONSTANT_COLOR,
        [(0, $d5b85d29c0b78636$export$99c8d898a9afbcee)]: gl.ONE_MINUS_CONSTANT_COLOR,
        [(0, $d5b85d29c0b78636$export$310cd2be38d13b56)]: gl.CONSTANT_ALPHA,
        [(0, $d5b85d29c0b78636$export$db77b8fbcf45dbf4)]: gl.ONE_MINUS_CONSTANT_ALPHA
    };
    function setBlending(blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, blendColor, blendAlpha, premultipliedAlpha) {
        if (blending === (0, $d5b85d29c0b78636$export$63b8d6b580fc65ba)) {
            if (currentBlendingEnabled === true) {
                disable(gl.BLEND);
                currentBlendingEnabled = false;
            }
            return;
        }
        if (currentBlendingEnabled === false) {
            enable(gl.BLEND);
            currentBlendingEnabled = true;
        }
        if (blending !== (0, $d5b85d29c0b78636$export$eda4864c68df1fa2)) {
            if (blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha) {
                if (currentBlendEquation !== (0, $d5b85d29c0b78636$export$20183a0484ce21a0) || currentBlendEquationAlpha !== (0, $d5b85d29c0b78636$export$20183a0484ce21a0)) {
                    gl.blendEquation(gl.FUNC_ADD);
                    currentBlendEquation = (0, $d5b85d29c0b78636$export$20183a0484ce21a0);
                    currentBlendEquationAlpha = (0, $d5b85d29c0b78636$export$20183a0484ce21a0);
                }
                if (premultipliedAlpha) switch(blending){
                    case 0, $d5b85d29c0b78636$export$5b29a26d96ee6af0:
                        gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
                        break;
                    case 0, $d5b85d29c0b78636$export$777d8f9551c2216b:
                        gl.blendFunc(gl.ONE, gl.ONE);
                        break;
                    case 0, $d5b85d29c0b78636$export$cdfa06f868e2e467:
                        gl.blendFuncSeparate(gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE);
                        break;
                    case 0, $d5b85d29c0b78636$export$4138e1c684b46a20:
                        gl.blendFuncSeparate(gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA);
                        break;
                    default:
                        console.error('THREE.WebGLState: Invalid blending: ', blending);
                        break;
                }
                else switch(blending){
                    case 0, $d5b85d29c0b78636$export$5b29a26d96ee6af0:
                        gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
                        break;
                    case 0, $d5b85d29c0b78636$export$777d8f9551c2216b:
                        gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
                        break;
                    case 0, $d5b85d29c0b78636$export$cdfa06f868e2e467:
                        gl.blendFuncSeparate(gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ZERO, gl.ONE);
                        break;
                    case 0, $d5b85d29c0b78636$export$4138e1c684b46a20:
                        gl.blendFunc(gl.ZERO, gl.SRC_COLOR);
                        break;
                    default:
                        console.error('THREE.WebGLState: Invalid blending: ', blending);
                        break;
                }
                currentBlendSrc = null;
                currentBlendDst = null;
                currentBlendSrcAlpha = null;
                currentBlendDstAlpha = null;
                currentBlendColor.set(0, 0, 0);
                currentBlendAlpha = 0;
                currentBlending = blending;
                currentPremultipledAlpha = premultipliedAlpha;
            }
            return;
        }
        // custom blending
        blendEquationAlpha = blendEquationAlpha || blendEquation;
        blendSrcAlpha = blendSrcAlpha || blendSrc;
        blendDstAlpha = blendDstAlpha || blendDst;
        if (blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha) {
            gl.blendEquationSeparate(equationToGL[blendEquation], equationToGL[blendEquationAlpha]);
            currentBlendEquation = blendEquation;
            currentBlendEquationAlpha = blendEquationAlpha;
        }
        if (blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha) {
            gl.blendFuncSeparate(factorToGL[blendSrc], factorToGL[blendDst], factorToGL[blendSrcAlpha], factorToGL[blendDstAlpha]);
            currentBlendSrc = blendSrc;
            currentBlendDst = blendDst;
            currentBlendSrcAlpha = blendSrcAlpha;
            currentBlendDstAlpha = blendDstAlpha;
        }
        if (blendColor.equals(currentBlendColor) === false || blendAlpha !== currentBlendAlpha) {
            gl.blendColor(blendColor.r, blendColor.g, blendColor.b, blendAlpha);
            currentBlendColor.copy(blendColor);
            currentBlendAlpha = blendAlpha;
        }
        currentBlending = blending;
        currentPremultipledAlpha = false;
    }
    function setMaterial(material, frontFaceCW) {
        material.side === (0, $d5b85d29c0b78636$export$3b296b6f144d5b03) ? disable(gl.CULL_FACE) : enable(gl.CULL_FACE);
        let flipSided = material.side === (0, $d5b85d29c0b78636$export$d9f0486e75b5ace);
        if (frontFaceCW) flipSided = !flipSided;
        setFlipSided(flipSided);
        material.blending === (0, $d5b85d29c0b78636$export$5b29a26d96ee6af0) && material.transparent === false ? setBlending((0, $d5b85d29c0b78636$export$63b8d6b580fc65ba)) : setBlending(material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.blendColor, material.blendAlpha, material.premultipliedAlpha);
        depthBuffer.setFunc(material.depthFunc);
        depthBuffer.setTest(material.depthTest);
        depthBuffer.setMask(material.depthWrite);
        colorBuffer.setMask(material.colorWrite);
        const stencilWrite = material.stencilWrite;
        stencilBuffer.setTest(stencilWrite);
        if (stencilWrite) {
            stencilBuffer.setMask(material.stencilWriteMask);
            stencilBuffer.setFunc(material.stencilFunc, material.stencilRef, material.stencilFuncMask);
            stencilBuffer.setOp(material.stencilFail, material.stencilZFail, material.stencilZPass);
        }
        setPolygonOffset(material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits);
        material.alphaToCoverage === true ? enable(gl.SAMPLE_ALPHA_TO_COVERAGE) : disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
    }
    //
    function setFlipSided(flipSided) {
        if (currentFlipSided !== flipSided) {
            if (flipSided) gl.frontFace(gl.CW);
            else gl.frontFace(gl.CCW);
            currentFlipSided = flipSided;
        }
    }
    function setCullFace(cullFace) {
        if (cullFace !== (0, $d5b85d29c0b78636$export$3237e1f2c1ea1f44)) {
            enable(gl.CULL_FACE);
            if (cullFace !== currentCullFace) {
                if (cullFace === (0, $d5b85d29c0b78636$export$b9a7b4fc5cb15f9b)) gl.cullFace(gl.BACK);
                else if (cullFace === (0, $d5b85d29c0b78636$export$b8058bcc7037d3f3)) gl.cullFace(gl.FRONT);
                else gl.cullFace(gl.FRONT_AND_BACK);
            }
        } else disable(gl.CULL_FACE);
        currentCullFace = cullFace;
    }
    function setLineWidth(width) {
        if (width !== currentLineWidth) {
            if (lineWidthAvailable) gl.lineWidth(width);
            currentLineWidth = width;
        }
    }
    function setPolygonOffset(polygonOffset, factor, units) {
        if (polygonOffset) {
            enable(gl.POLYGON_OFFSET_FILL);
            if (currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units) {
                gl.polygonOffset(factor, units);
                currentPolygonOffsetFactor = factor;
                currentPolygonOffsetUnits = units;
            }
        } else disable(gl.POLYGON_OFFSET_FILL);
    }
    function setScissorTest(scissorTest) {
        if (scissorTest) enable(gl.SCISSOR_TEST);
        else disable(gl.SCISSOR_TEST);
    }
    // texture
    function activeTexture(webglSlot) {
        if (webglSlot === undefined) webglSlot = gl.TEXTURE0 + maxTextures - 1;
        if (currentTextureSlot !== webglSlot) {
            gl.activeTexture(webglSlot);
            currentTextureSlot = webglSlot;
        }
    }
    function bindTexture(webglType, webglTexture, webglSlot) {
        if (webglSlot === undefined) {
            if (currentTextureSlot === null) webglSlot = gl.TEXTURE0 + maxTextures - 1;
            else webglSlot = currentTextureSlot;
        }
        let boundTexture = currentBoundTextures[webglSlot];
        if (boundTexture === undefined) {
            boundTexture = {
                type: undefined,
                texture: undefined
            };
            currentBoundTextures[webglSlot] = boundTexture;
        }
        if (boundTexture.type !== webglType || boundTexture.texture !== webglTexture) {
            if (currentTextureSlot !== webglSlot) {
                gl.activeTexture(webglSlot);
                currentTextureSlot = webglSlot;
            }
            gl.bindTexture(webglType, webglTexture || emptyTextures[webglType]);
            boundTexture.type = webglType;
            boundTexture.texture = webglTexture;
        }
    }
    function unbindTexture() {
        const boundTexture = currentBoundTextures[currentTextureSlot];
        if (boundTexture !== undefined && boundTexture.type !== undefined) {
            gl.bindTexture(boundTexture.type, null);
            boundTexture.type = undefined;
            boundTexture.texture = undefined;
        }
    }
    function compressedTexImage2D() {
        try {
            gl.compressedTexImage2D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function compressedTexImage3D() {
        try {
            gl.compressedTexImage3D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function texSubImage2D() {
        try {
            gl.texSubImage2D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function texSubImage3D() {
        try {
            gl.texSubImage3D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function compressedTexSubImage2D() {
        try {
            gl.compressedTexSubImage2D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function compressedTexSubImage3D() {
        try {
            gl.compressedTexSubImage3D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function texStorage2D() {
        try {
            gl.texStorage2D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function texStorage3D() {
        try {
            gl.texStorage3D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function texImage2D() {
        try {
            gl.texImage2D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    function texImage3D() {
        try {
            gl.texImage3D.apply(gl, arguments);
        } catch (error) {
            console.error('THREE.WebGLState:', error);
        }
    }
    //
    function scissor(scissor) {
        if (currentScissor.equals(scissor) === false) {
            gl.scissor(scissor.x, scissor.y, scissor.z, scissor.w);
            currentScissor.copy(scissor);
        }
    }
    function viewport(viewport) {
        if (currentViewport.equals(viewport) === false) {
            gl.viewport(viewport.x, viewport.y, viewport.z, viewport.w);
            currentViewport.copy(viewport);
        }
    }
    function updateUBOMapping(uniformsGroup, program) {
        let mapping = uboProgramMap.get(program);
        if (mapping === undefined) {
            mapping = new WeakMap();
            uboProgramMap.set(program, mapping);
        }
        let blockIndex = mapping.get(uniformsGroup);
        if (blockIndex === undefined) {
            blockIndex = gl.getUniformBlockIndex(program, uniformsGroup.name);
            mapping.set(uniformsGroup, blockIndex);
        }
    }
    function uniformBlockBinding(uniformsGroup, program) {
        const mapping = uboProgramMap.get(program);
        const blockIndex = mapping.get(uniformsGroup);
        if (uboBindings.get(program) !== blockIndex) {
            // bind shader specific block index to global block point
            gl.uniformBlockBinding(program, blockIndex, uniformsGroup.__bindingPointIndex);
            uboBindings.set(program, blockIndex);
        }
    }
    //
    function reset() {
        // reset state
        gl.disable(gl.BLEND);
        gl.disable(gl.CULL_FACE);
        gl.disable(gl.DEPTH_TEST);
        gl.disable(gl.POLYGON_OFFSET_FILL);
        gl.disable(gl.SCISSOR_TEST);
        gl.disable(gl.STENCIL_TEST);
        gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
        gl.blendEquation(gl.FUNC_ADD);
        gl.blendFunc(gl.ONE, gl.ZERO);
        gl.blendFuncSeparate(gl.ONE, gl.ZERO, gl.ONE, gl.ZERO);
        gl.blendColor(0, 0, 0, 0);
        gl.colorMask(true, true, true, true);
        gl.clearColor(0, 0, 0, 0);
        gl.depthMask(true);
        gl.depthFunc(gl.LESS);
        depthBuffer.setReversed(false);
        gl.clearDepth(1);
        gl.stencilMask(0xffffffff);
        gl.stencilFunc(gl.ALWAYS, 0, 0xffffffff);
        gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
        gl.clearStencil(0);
        gl.cullFace(gl.BACK);
        gl.frontFace(gl.CCW);
        gl.polygonOffset(0, 0);
        gl.activeTexture(gl.TEXTURE0);
        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
        gl.useProgram(null);
        gl.lineWidth(1);
        gl.scissor(0, 0, gl.canvas.width, gl.canvas.height);
        gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
        // reset internals
        enabledCapabilities = {};
        currentTextureSlot = null;
        currentBoundTextures = {};
        currentBoundFramebuffers = {};
        currentDrawbuffers = new WeakMap();
        defaultDrawbuffers = [];
        currentProgram = null;
        currentBlendingEnabled = false;
        currentBlending = null;
        currentBlendEquation = null;
        currentBlendSrc = null;
        currentBlendDst = null;
        currentBlendEquationAlpha = null;
        currentBlendSrcAlpha = null;
        currentBlendDstAlpha = null;
        currentBlendColor = new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0, 0, 0);
        currentBlendAlpha = 0;
        currentPremultipledAlpha = false;
        currentFlipSided = null;
        currentCullFace = null;
        currentLineWidth = null;
        currentPolygonOffsetFactor = null;
        currentPolygonOffsetUnits = null;
        currentScissor.set(0, 0, gl.canvas.width, gl.canvas.height);
        currentViewport.set(0, 0, gl.canvas.width, gl.canvas.height);
        colorBuffer.reset();
        depthBuffer.reset();
        stencilBuffer.reset();
    }
    return {
        buffers: {
            color: colorBuffer,
            depth: depthBuffer,
            stencil: stencilBuffer
        },
        enable: enable,
        disable: disable,
        bindFramebuffer: bindFramebuffer,
        drawBuffers: drawBuffers,
        useProgram: useProgram,
        setBlending: setBlending,
        setMaterial: setMaterial,
        setFlipSided: setFlipSided,
        setCullFace: setCullFace,
        setLineWidth: setLineWidth,
        setPolygonOffset: setPolygonOffset,
        setScissorTest: setScissorTest,
        activeTexture: activeTexture,
        bindTexture: bindTexture,
        unbindTexture: unbindTexture,
        compressedTexImage2D: compressedTexImage2D,
        compressedTexImage3D: compressedTexImage3D,
        texImage2D: texImage2D,
        texImage3D: texImage3D,
        updateUBOMapping: updateUBOMapping,
        uniformBlockBinding: uniformBlockBinding,
        texStorage2D: texStorage2D,
        texStorage3D: texStorage3D,
        texSubImage2D: texSubImage2D,
        texSubImage3D: texSubImage3D,
        compressedTexSubImage2D: compressedTexSubImage2D,
        compressedTexSubImage3D: compressedTexSubImage3D,
        scissor: scissor,
        viewport: viewport,
        reset: reset
    };
}
function $3dd44ec8564e7230$var$WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info) {
    const multisampledRTTExt = extensions.has('WEBGL_multisampled_render_to_texture') ? extensions.get('WEBGL_multisampled_render_to_texture') : null;
    const supportsInvalidateFramebuffer = typeof navigator === 'undefined' ? false : /OculusBrowser/g.test(navigator.userAgent);
    const _imageDimensions = new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)();
    const _videoTextures = new WeakMap();
    let _canvas;
    const _sources = new WeakMap(); // maps WebglTexture objects to instances of Source
    // cordova iOS (as of 5.0) still uses UIWebView, which provides OffscreenCanvas,
    // also OffscreenCanvas.getContext("webgl"), but not OffscreenCanvas.getContext("2d")!
    // Some implementations may only implement OffscreenCanvas partially (e.g. lacking 2d).
    let useOffscreenCanvas = false;
    try {
        useOffscreenCanvas = typeof OffscreenCanvas !== 'undefined' && new OffscreenCanvas(1, 1).getContext('2d') !== null;
    } catch (err) {
    // Ignore any errors
    }
    function createCanvas(width, height) {
        // Use OffscreenCanvas when available. Specially needed in web workers
        return useOffscreenCanvas ? // eslint-disable-next-line compat/compat
        new OffscreenCanvas(width, height) : (0, $d5b85d29c0b78636$export$7094a064528c7fee)('canvas');
    }
    function resizeImage(image, needsNewCanvas, maxSize) {
        let scale = 1;
        const dimensions = getDimensions(image);
        // handle case if texture exceeds max size
        if (dimensions.width > maxSize || dimensions.height > maxSize) scale = maxSize / Math.max(dimensions.width, dimensions.height);
        // only perform resize if necessary
        if (scale < 1) {
            // only perform resize for certain image types
            if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap || typeof VideoFrame !== 'undefined' && image instanceof VideoFrame) {
                const width = Math.floor(scale * dimensions.width);
                const height = Math.floor(scale * dimensions.height);
                if (_canvas === undefined) _canvas = createCanvas(width, height);
                // cube textures can't reuse the same canvas
                const canvas = needsNewCanvas ? createCanvas(width, height) : _canvas;
                canvas.width = width;
                canvas.height = height;
                const context = canvas.getContext('2d');
                context.drawImage(image, 0, 0, width, height);
                console.warn('THREE.WebGLRenderer: Texture has been resized from (' + dimensions.width + 'x' + dimensions.height + ') to (' + width + 'x' + height + ').');
                return canvas;
            } else {
                if ('data' in image) console.warn('THREE.WebGLRenderer: Image in DataTexture is too big (' + dimensions.width + 'x' + dimensions.height + ').');
                return image;
            }
        }
        return image;
    }
    function textureNeedsGenerateMipmaps(texture) {
        return texture.generateMipmaps;
    }
    function generateMipmap(target) {
        _gl.generateMipmap(target);
    }
    function getTargetType(texture) {
        if (texture.isWebGLCubeRenderTarget) return _gl.TEXTURE_CUBE_MAP;
        if (texture.isWebGL3DRenderTarget) return _gl.TEXTURE_3D;
        if (texture.isWebGLArrayRenderTarget || texture.isCompressedArrayTexture) return _gl.TEXTURE_2D_ARRAY;
        return _gl.TEXTURE_2D;
    }
    function getInternalFormat(internalFormatName, glFormat, glType, colorSpace, forceLinearTransfer = false) {
        if (internalFormatName !== null) {
            if (_gl[internalFormatName] !== undefined) return _gl[internalFormatName];
            console.warn('THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format \'' + internalFormatName + '\'');
        }
        let internalFormat = glFormat;
        if (glFormat === _gl.RED) {
            if (glType === _gl.FLOAT) internalFormat = _gl.R32F;
            if (glType === _gl.HALF_FLOAT) internalFormat = _gl.R16F;
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.R8;
        }
        if (glFormat === _gl.RED_INTEGER) {
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.R8UI;
            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.R16UI;
            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.R32UI;
            if (glType === _gl.BYTE) internalFormat = _gl.R8I;
            if (glType === _gl.SHORT) internalFormat = _gl.R16I;
            if (glType === _gl.INT) internalFormat = _gl.R32I;
        }
        if (glFormat === _gl.RG) {
            if (glType === _gl.FLOAT) internalFormat = _gl.RG32F;
            if (glType === _gl.HALF_FLOAT) internalFormat = _gl.RG16F;
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RG8;
        }
        if (glFormat === _gl.RG_INTEGER) {
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RG8UI;
            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RG16UI;
            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RG32UI;
            if (glType === _gl.BYTE) internalFormat = _gl.RG8I;
            if (glType === _gl.SHORT) internalFormat = _gl.RG16I;
            if (glType === _gl.INT) internalFormat = _gl.RG32I;
        }
        if (glFormat === _gl.RGB_INTEGER) {
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RGB8UI;
            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RGB16UI;
            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RGB32UI;
            if (glType === _gl.BYTE) internalFormat = _gl.RGB8I;
            if (glType === _gl.SHORT) internalFormat = _gl.RGB16I;
            if (glType === _gl.INT) internalFormat = _gl.RGB32I;
        }
        if (glFormat === _gl.RGBA_INTEGER) {
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = _gl.RGBA8UI;
            if (glType === _gl.UNSIGNED_SHORT) internalFormat = _gl.RGBA16UI;
            if (glType === _gl.UNSIGNED_INT) internalFormat = _gl.RGBA32UI;
            if (glType === _gl.BYTE) internalFormat = _gl.RGBA8I;
            if (glType === _gl.SHORT) internalFormat = _gl.RGBA16I;
            if (glType === _gl.INT) internalFormat = _gl.RGBA32I;
        }
        if (glFormat === _gl.RGB) {
            if (glType === _gl.UNSIGNED_INT_5_9_9_9_REV) internalFormat = _gl.RGB9_E5;
        }
        if (glFormat === _gl.RGBA) {
            const transfer = forceLinearTransfer ? (0, $d5b85d29c0b78636$export$f197347d588c1b4a) : (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(colorSpace);
            if (glType === _gl.FLOAT) internalFormat = _gl.RGBA32F;
            if (glType === _gl.HALF_FLOAT) internalFormat = _gl.RGBA16F;
            if (glType === _gl.UNSIGNED_BYTE) internalFormat = transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? _gl.SRGB8_ALPHA8 : _gl.RGBA8;
            if (glType === _gl.UNSIGNED_SHORT_4_4_4_4) internalFormat = _gl.RGBA4;
            if (glType === _gl.UNSIGNED_SHORT_5_5_5_1) internalFormat = _gl.RGB5_A1;
        }
        if (internalFormat === _gl.R16F || internalFormat === _gl.R32F || internalFormat === _gl.RG16F || internalFormat === _gl.RG32F || internalFormat === _gl.RGBA16F || internalFormat === _gl.RGBA32F) extensions.get('EXT_color_buffer_float');
        return internalFormat;
    }
    function getInternalDepthFormat(useStencil, depthType) {
        let glInternalFormat;
        if (useStencil) {
            if (depthType === null || depthType === (0, $d5b85d29c0b78636$export$c3c7fc4518ebba96) || depthType === (0, $d5b85d29c0b78636$export$6c8ea339bfab1301)) glInternalFormat = _gl.DEPTH24_STENCIL8;
            else if (depthType === (0, $d5b85d29c0b78636$export$f6d331659b644596)) glInternalFormat = _gl.DEPTH32F_STENCIL8;
            else if (depthType === (0, $d5b85d29c0b78636$export$c63dc51868b06a9d)) {
                glInternalFormat = _gl.DEPTH24_STENCIL8;
                console.warn('DepthTexture: 16 bit depth attachment is not supported with stencil. Using 24-bit attachment.');
            }
        } else {
            if (depthType === null || depthType === (0, $d5b85d29c0b78636$export$c3c7fc4518ebba96) || depthType === (0, $d5b85d29c0b78636$export$6c8ea339bfab1301)) glInternalFormat = _gl.DEPTH_COMPONENT24;
            else if (depthType === (0, $d5b85d29c0b78636$export$f6d331659b644596)) glInternalFormat = _gl.DEPTH_COMPONENT32F;
            else if (depthType === (0, $d5b85d29c0b78636$export$c63dc51868b06a9d)) glInternalFormat = _gl.DEPTH_COMPONENT16;
        }
        return glInternalFormat;
    }
    function getMipLevels(texture, image) {
        if (textureNeedsGenerateMipmaps(texture) === true || texture.isFramebufferTexture && texture.minFilter !== (0, $d5b85d29c0b78636$export$727aa5ec3fe39bf0) && texture.minFilter !== (0, $d5b85d29c0b78636$export$8a72f490b25c56c8)) return Math.log2(Math.max(image.width, image.height)) + 1;
        else if (texture.mipmaps !== undefined && texture.mipmaps.length > 0) // user-defined mipmaps
        return texture.mipmaps.length;
        else if (texture.isCompressedTexture && Array.isArray(texture.image)) return image.mipmaps.length;
        else // texture without mipmaps (only base level)
        return 1;
    }
    //
    function onTextureDispose(event) {
        const texture = event.target;
        texture.removeEventListener('dispose', onTextureDispose);
        deallocateTexture(texture);
        if (texture.isVideoTexture) _videoTextures.delete(texture);
    }
    function onRenderTargetDispose(event) {
        const renderTarget = event.target;
        renderTarget.removeEventListener('dispose', onRenderTargetDispose);
        deallocateRenderTarget(renderTarget);
    }
    //
    function deallocateTexture(texture) {
        const textureProperties = properties.get(texture);
        if (textureProperties.__webglInit === undefined) return;
        // check if it's necessary to remove the WebGLTexture object
        const source = texture.source;
        const webglTextures = _sources.get(source);
        if (webglTextures) {
            const webglTexture = webglTextures[textureProperties.__cacheKey];
            webglTexture.usedTimes--;
            // the WebGLTexture object is not used anymore, remove it
            if (webglTexture.usedTimes === 0) deleteTexture(texture);
            // remove the weak map entry if no WebGLTexture uses the source anymore
            if (Object.keys(webglTextures).length === 0) _sources.delete(source);
        }
        properties.remove(texture);
    }
    function deleteTexture(texture) {
        const textureProperties = properties.get(texture);
        _gl.deleteTexture(textureProperties.__webglTexture);
        const source = texture.source;
        const webglTextures = _sources.get(source);
        delete webglTextures[textureProperties.__cacheKey];
        info.memory.textures--;
    }
    function deallocateRenderTarget(renderTarget) {
        const renderTargetProperties = properties.get(renderTarget);
        if (renderTarget.depthTexture) {
            renderTarget.depthTexture.dispose();
            properties.remove(renderTarget.depthTexture);
        }
        if (renderTarget.isWebGLCubeRenderTarget) for(let i = 0; i < 6; i++){
            if (Array.isArray(renderTargetProperties.__webglFramebuffer[i])) for(let level = 0; level < renderTargetProperties.__webglFramebuffer[i].length; level++)_gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i][level]);
            else _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i]);
            if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer[i]);
        }
        else {
            if (Array.isArray(renderTargetProperties.__webglFramebuffer)) for(let level = 0; level < renderTargetProperties.__webglFramebuffer.length; level++)_gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[level]);
            else _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer);
            if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer);
            if (renderTargetProperties.__webglMultisampledFramebuffer) _gl.deleteFramebuffer(renderTargetProperties.__webglMultisampledFramebuffer);
            if (renderTargetProperties.__webglColorRenderbuffer) {
                for(let i = 0; i < renderTargetProperties.__webglColorRenderbuffer.length; i++)if (renderTargetProperties.__webglColorRenderbuffer[i]) _gl.deleteRenderbuffer(renderTargetProperties.__webglColorRenderbuffer[i]);
            }
            if (renderTargetProperties.__webglDepthRenderbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthRenderbuffer);
        }
        const textures = renderTarget.textures;
        for(let i = 0, il = textures.length; i < il; i++){
            const attachmentProperties = properties.get(textures[i]);
            if (attachmentProperties.__webglTexture) {
                _gl.deleteTexture(attachmentProperties.__webglTexture);
                info.memory.textures--;
            }
            properties.remove(textures[i]);
        }
        properties.remove(renderTarget);
    }
    //
    let textureUnits = 0;
    function resetTextureUnits() {
        textureUnits = 0;
    }
    function allocateTextureUnit() {
        const textureUnit = textureUnits;
        if (textureUnit >= capabilities.maxTextures) console.warn('THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures);
        textureUnits += 1;
        return textureUnit;
    }
    function getTextureCacheKey(texture) {
        const array = [];
        array.push(texture.wrapS);
        array.push(texture.wrapT);
        array.push(texture.wrapR || 0);
        array.push(texture.magFilter);
        array.push(texture.minFilter);
        array.push(texture.anisotropy);
        array.push(texture.internalFormat);
        array.push(texture.format);
        array.push(texture.type);
        array.push(texture.generateMipmaps);
        array.push(texture.premultiplyAlpha);
        array.push(texture.flipY);
        array.push(texture.unpackAlignment);
        array.push(texture.colorSpace);
        return array.join();
    }
    //
    function setTexture2D(texture, slot) {
        const textureProperties = properties.get(texture);
        if (texture.isVideoTexture) updateVideoTexture(texture);
        if (texture.isRenderTargetTexture === false && texture.version > 0 && textureProperties.__version !== texture.version) {
            const image = texture.image;
            if (image === null) console.warn('THREE.WebGLRenderer: Texture marked for update but no image data found.');
            else if (image.complete === false) console.warn('THREE.WebGLRenderer: Texture marked for update but image is incomplete');
            else {
                uploadTexture(textureProperties, texture, slot);
                return;
            }
        }
        state.bindTexture(_gl.TEXTURE_2D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
    }
    function setTexture2DArray(texture, slot) {
        const textureProperties = properties.get(texture);
        if (texture.version > 0 && textureProperties.__version !== texture.version) {
            uploadTexture(textureProperties, texture, slot);
            return;
        }
        state.bindTexture(_gl.TEXTURE_2D_ARRAY, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
    }
    function setTexture3D(texture, slot) {
        const textureProperties = properties.get(texture);
        if (texture.version > 0 && textureProperties.__version !== texture.version) {
            uploadTexture(textureProperties, texture, slot);
            return;
        }
        state.bindTexture(_gl.TEXTURE_3D, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
    }
    function setTextureCube(texture, slot) {
        const textureProperties = properties.get(texture);
        if (texture.version > 0 && textureProperties.__version !== texture.version) {
            uploadCubeTexture(textureProperties, texture, slot);
            return;
        }
        state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
    }
    const wrappingToGL = {
        [(0, $d5b85d29c0b78636$export$533346c8e8dac0f5)]: _gl.REPEAT,
        [(0, $d5b85d29c0b78636$export$9d9334239a5a5e06)]: _gl.CLAMP_TO_EDGE,
        [(0, $d5b85d29c0b78636$export$c7e7c00b14f51a4f)]: _gl.MIRRORED_REPEAT
    };
    const filterToGL = {
        [(0, $d5b85d29c0b78636$export$727aa5ec3fe39bf0)]: _gl.NEAREST,
        [(0, $d5b85d29c0b78636$export$d129e38cf6feaa8c)]: _gl.NEAREST_MIPMAP_NEAREST,
        [(0, $d5b85d29c0b78636$export$d2327c1afe5bfdf2)]: _gl.NEAREST_MIPMAP_LINEAR,
        [(0, $d5b85d29c0b78636$export$8a72f490b25c56c8)]: _gl.LINEAR,
        [(0, $d5b85d29c0b78636$export$19a719f377145a13)]: _gl.LINEAR_MIPMAP_NEAREST,
        [(0, $d5b85d29c0b78636$export$5d8599b6a933fb1b)]: _gl.LINEAR_MIPMAP_LINEAR
    };
    const compareToGL = {
        [(0, $d5b85d29c0b78636$export$d9e2d19a747baaab)]: _gl.NEVER,
        [(0, $d5b85d29c0b78636$export$187b73a3e352c145)]: _gl.ALWAYS,
        [(0, $d5b85d29c0b78636$export$36bcf49c713b3eb7)]: _gl.LESS,
        [(0, $d5b85d29c0b78636$export$64eea11eb407ddf1)]: _gl.LEQUAL,
        [(0, $d5b85d29c0b78636$export$66f28d946fc6a0d5)]: _gl.EQUAL,
        [(0, $d5b85d29c0b78636$export$1cdcb70d53d65f61)]: _gl.GEQUAL,
        [(0, $d5b85d29c0b78636$export$155af022118f3a38)]: _gl.GREATER,
        [(0, $d5b85d29c0b78636$export$67ab95dde6bed156)]: _gl.NOTEQUAL
    };
    function setTextureParameters(textureType, texture) {
        if (texture.type === (0, $d5b85d29c0b78636$export$f6d331659b644596) && extensions.has('OES_texture_float_linear') === false && (texture.magFilter === (0, $d5b85d29c0b78636$export$8a72f490b25c56c8) || texture.magFilter === (0, $d5b85d29c0b78636$export$19a719f377145a13) || texture.magFilter === (0, $d5b85d29c0b78636$export$d2327c1afe5bfdf2) || texture.magFilter === (0, $d5b85d29c0b78636$export$5d8599b6a933fb1b) || texture.minFilter === (0, $d5b85d29c0b78636$export$8a72f490b25c56c8) || texture.minFilter === (0, $d5b85d29c0b78636$export$19a719f377145a13) || texture.minFilter === (0, $d5b85d29c0b78636$export$d2327c1afe5bfdf2) || texture.minFilter === (0, $d5b85d29c0b78636$export$5d8599b6a933fb1b))) console.warn('THREE.WebGLRenderer: Unable to use linear filtering with floating point textures. OES_texture_float_linear not supported on this device.');
        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_S, wrappingToGL[texture.wrapS]);
        _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_T, wrappingToGL[texture.wrapT]);
        if (textureType === _gl.TEXTURE_3D || textureType === _gl.TEXTURE_2D_ARRAY) _gl.texParameteri(textureType, _gl.TEXTURE_WRAP_R, wrappingToGL[texture.wrapR]);
        _gl.texParameteri(textureType, _gl.TEXTURE_MAG_FILTER, filterToGL[texture.magFilter]);
        _gl.texParameteri(textureType, _gl.TEXTURE_MIN_FILTER, filterToGL[texture.minFilter]);
        if (texture.compareFunction) {
            _gl.texParameteri(textureType, _gl.TEXTURE_COMPARE_MODE, _gl.COMPARE_REF_TO_TEXTURE);
            _gl.texParameteri(textureType, _gl.TEXTURE_COMPARE_FUNC, compareToGL[texture.compareFunction]);
        }
        if (extensions.has('EXT_texture_filter_anisotropic') === true) {
            if (texture.magFilter === (0, $d5b85d29c0b78636$export$727aa5ec3fe39bf0)) return;
            if (texture.minFilter !== (0, $d5b85d29c0b78636$export$d2327c1afe5bfdf2) && texture.minFilter !== (0, $d5b85d29c0b78636$export$5d8599b6a933fb1b)) return;
            if (texture.type === (0, $d5b85d29c0b78636$export$f6d331659b644596) && extensions.has('OES_texture_float_linear') === false) return; // verify extension
            if (texture.anisotropy > 1 || properties.get(texture).__currentAnisotropy) {
                const extension = extensions.get('EXT_texture_filter_anisotropic');
                _gl.texParameterf(textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(texture.anisotropy, capabilities.getMaxAnisotropy()));
                properties.get(texture).__currentAnisotropy = texture.anisotropy;
            }
        }
    }
    function initTexture(textureProperties, texture) {
        let forceUpload = false;
        if (textureProperties.__webglInit === undefined) {
            textureProperties.__webglInit = true;
            texture.addEventListener('dispose', onTextureDispose);
        }
        // create Source <-> WebGLTextures mapping if necessary
        const source = texture.source;
        let webglTextures = _sources.get(source);
        if (webglTextures === undefined) {
            webglTextures = {};
            _sources.set(source, webglTextures);
        }
        // check if there is already a WebGLTexture object for the given texture parameters
        const textureCacheKey = getTextureCacheKey(texture);
        if (textureCacheKey !== textureProperties.__cacheKey) {
            // if not, create a new instance of WebGLTexture
            if (webglTextures[textureCacheKey] === undefined) {
                // create new entry
                webglTextures[textureCacheKey] = {
                    texture: _gl.createTexture(),
                    usedTimes: 0
                };
                info.memory.textures++;
                // when a new instance of WebGLTexture was created, a texture upload is required
                // even if the image contents are identical
                forceUpload = true;
            }
            webglTextures[textureCacheKey].usedTimes++;
            // every time the texture cache key changes, it's necessary to check if an instance of
            // WebGLTexture can be deleted in order to avoid a memory leak.
            const webglTexture = webglTextures[textureProperties.__cacheKey];
            if (webglTexture !== undefined) {
                webglTextures[textureProperties.__cacheKey].usedTimes--;
                if (webglTexture.usedTimes === 0) deleteTexture(texture);
            }
            // store references to cache key and WebGLTexture object
            textureProperties.__cacheKey = textureCacheKey;
            textureProperties.__webglTexture = webglTextures[textureCacheKey].texture;
        }
        return forceUpload;
    }
    function uploadTexture(textureProperties, texture, slot) {
        let textureType = _gl.TEXTURE_2D;
        if (texture.isDataArrayTexture || texture.isCompressedArrayTexture) textureType = _gl.TEXTURE_2D_ARRAY;
        if (texture.isData3DTexture) textureType = _gl.TEXTURE_3D;
        const forceUpload = initTexture(textureProperties, texture);
        const source = texture.source;
        state.bindTexture(textureType, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
        const sourceProperties = properties.get(source);
        if (source.version !== sourceProperties.__version || forceUpload === true) {
            state.activeTexture(_gl.TEXTURE0 + slot);
            const workingPrimaries = (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getPrimaries((0, $d5b85d29c0b78636$export$5e6fd513f44698c).workingColorSpace);
            const texturePrimaries = texture.colorSpace === (0, $d5b85d29c0b78636$export$bfcb490c2dd3db51) ? null : (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getPrimaries(texture.colorSpace);
            const unpackConversion = texture.colorSpace === (0, $d5b85d29c0b78636$export$bfcb490c2dd3db51) || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;
            _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY);
            _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha);
            _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment);
            _gl.pixelStorei(_gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion);
            let image = resizeImage(texture.image, false, capabilities.maxTextureSize);
            image = verifyColorSpace(texture, image);
            const glFormat = utils.convert(texture.format, texture.colorSpace);
            const glType = utils.convert(texture.type);
            let glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace, texture.isVideoTexture);
            setTextureParameters(textureType, texture);
            let mipmap;
            const mipmaps = texture.mipmaps;
            const useTexStorage = texture.isVideoTexture !== true;
            const allocateMemory = sourceProperties.__version === undefined || forceUpload === true;
            const dataReady = source.dataReady;
            const levels = getMipLevels(texture, image);
            if (texture.isDepthTexture) {
                glInternalFormat = getInternalDepthFormat(texture.format === (0, $d5b85d29c0b78636$export$1e113ac2d0905829), texture.type);
                //
                if (allocateMemory) {
                    if (useTexStorage) state.texStorage2D(_gl.TEXTURE_2D, 1, glInternalFormat, image.width, image.height);
                    else state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null);
                }
            } else if (texture.isDataTexture) {
                // use manually created mipmaps if available
                // if there are no manual mipmaps
                // set 0 level mipmap and then use GL to generate other mipmap levels
                if (mipmaps.length > 0) {
                    if (useTexStorage && allocateMemory) state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height);
                    for(let i = 0, il = mipmaps.length; i < il; i++){
                        mipmap = mipmaps[i];
                        if (useTexStorage) {
                            if (dataReady) state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
                        } else state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data);
                    }
                    texture.generateMipmaps = false;
                } else if (useTexStorage) {
                    if (allocateMemory) state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height);
                    if (dataReady) state.texSubImage2D(_gl.TEXTURE_2D, 0, 0, 0, image.width, image.height, glFormat, glType, image.data);
                } else state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data);
            } else if (texture.isCompressedTexture) {
                if (texture.isCompressedArrayTexture) {
                    if (useTexStorage && allocateMemory) state.texStorage3D(_gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height, image.depth);
                    for(let i = 0, il = mipmaps.length; i < il; i++){
                        mipmap = mipmaps[i];
                        if (texture.format !== (0, $d5b85d29c0b78636$export$3f8bb04b555a363c)) {
                            if (glFormat !== null) {
                                if (useTexStorage) {
                                    if (dataReady) {
                                        if (texture.layerUpdates.size > 0) {
                                            const layerByteLength = (0, $d5b85d29c0b78636$export$cc8c3b705bb8e6e2)(mipmap.width, mipmap.height, texture.format, texture.type);
                                            for (const layerIndex of texture.layerUpdates){
                                                const layerData = mipmap.data.subarray(layerIndex * layerByteLength / mipmap.data.BYTES_PER_ELEMENT, (layerIndex + 1) * layerByteLength / mipmap.data.BYTES_PER_ELEMENT);
                                                state.compressedTexSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, layerIndex, mipmap.width, mipmap.height, 1, glFormat, layerData);
                                            }
                                            texture.clearLayerUpdates();
                                        } else state.compressedTexSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, mipmap.data);
                                    }
                                } else state.compressedTexImage3D(_gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, mipmap.data, 0, 0);
                            } else console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()');
                        } else {
                            if (useTexStorage) {
                                if (dataReady) state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, i, 0, 0, 0, mipmap.width, mipmap.height, image.depth, glFormat, glType, mipmap.data);
                            } else state.texImage3D(_gl.TEXTURE_2D_ARRAY, i, glInternalFormat, mipmap.width, mipmap.height, image.depth, 0, glFormat, glType, mipmap.data);
                        }
                    }
                } else {
                    if (useTexStorage && allocateMemory) state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, mipmaps[0].width, mipmaps[0].height);
                    for(let i = 0, il = mipmaps.length; i < il; i++){
                        mipmap = mipmaps[i];
                        if (texture.format !== (0, $d5b85d29c0b78636$export$3f8bb04b555a363c)) {
                            if (glFormat !== null) {
                                if (useTexStorage) {
                                    if (dataReady) state.compressedTexSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data);
                                } else state.compressedTexImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data);
                            } else console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()');
                        } else {
                            if (useTexStorage) {
                                if (dataReady) state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
                            } else state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data);
                        }
                    }
                }
            } else if (texture.isDataArrayTexture) {
                if (useTexStorage) {
                    if (allocateMemory) state.texStorage3D(_gl.TEXTURE_2D_ARRAY, levels, glInternalFormat, image.width, image.height, image.depth);
                    if (dataReady) {
                        if (texture.layerUpdates.size > 0) {
                            const layerByteLength = (0, $d5b85d29c0b78636$export$cc8c3b705bb8e6e2)(image.width, image.height, texture.format, texture.type);
                            for (const layerIndex of texture.layerUpdates){
                                const layerData = image.data.subarray(layerIndex * layerByteLength / image.data.BYTES_PER_ELEMENT, (layerIndex + 1) * layerByteLength / image.data.BYTES_PER_ELEMENT);
                                state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, 0, 0, 0, layerIndex, image.width, image.height, 1, glFormat, glType, layerData);
                            }
                            texture.clearLayerUpdates();
                        } else state.texSubImage3D(_gl.TEXTURE_2D_ARRAY, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data);
                    }
                } else state.texImage3D(_gl.TEXTURE_2D_ARRAY, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data);
            } else if (texture.isData3DTexture) {
                if (useTexStorage) {
                    if (allocateMemory) state.texStorage3D(_gl.TEXTURE_3D, levels, glInternalFormat, image.width, image.height, image.depth);
                    if (dataReady) state.texSubImage3D(_gl.TEXTURE_3D, 0, 0, 0, 0, image.width, image.height, image.depth, glFormat, glType, image.data);
                } else state.texImage3D(_gl.TEXTURE_3D, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data);
            } else if (texture.isFramebufferTexture) {
                if (allocateMemory) {
                    if (useTexStorage) state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, image.width, image.height);
                    else {
                        let width = image.width, height = image.height;
                        for(let i = 0; i < levels; i++){
                            state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, width, height, 0, glFormat, glType, null);
                            width >>= 1;
                            height >>= 1;
                        }
                    }
                }
            } else {
                // regular Texture (image, video, canvas)
                // use manually created mipmaps if available
                // if there are no manual mipmaps
                // set 0 level mipmap and then use GL to generate other mipmap levels
                if (mipmaps.length > 0) {
                    if (useTexStorage && allocateMemory) {
                        const dimensions = getDimensions(mipmaps[0]);
                        state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height);
                    }
                    for(let i = 0, il = mipmaps.length; i < il; i++){
                        mipmap = mipmaps[i];
                        if (useTexStorage) {
                            if (dataReady) state.texSubImage2D(_gl.TEXTURE_2D, i, 0, 0, glFormat, glType, mipmap);
                        } else state.texImage2D(_gl.TEXTURE_2D, i, glInternalFormat, glFormat, glType, mipmap);
                    }
                    texture.generateMipmaps = false;
                } else if (useTexStorage) {
                    if (allocateMemory) {
                        const dimensions = getDimensions(image);
                        state.texStorage2D(_gl.TEXTURE_2D, levels, glInternalFormat, dimensions.width, dimensions.height);
                    }
                    if (dataReady) state.texSubImage2D(_gl.TEXTURE_2D, 0, 0, 0, glFormat, glType, image);
                } else state.texImage2D(_gl.TEXTURE_2D, 0, glInternalFormat, glFormat, glType, image);
            }
            if (textureNeedsGenerateMipmaps(texture)) generateMipmap(textureType);
            sourceProperties.__version = source.version;
            if (texture.onUpdate) texture.onUpdate(texture);
        }
        textureProperties.__version = texture.version;
    }
    function uploadCubeTexture(textureProperties, texture, slot) {
        if (texture.image.length !== 6) return;
        const forceUpload = initTexture(textureProperties, texture);
        const source = texture.source;
        state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture, _gl.TEXTURE0 + slot);
        const sourceProperties = properties.get(source);
        if (source.version !== sourceProperties.__version || forceUpload === true) {
            state.activeTexture(_gl.TEXTURE0 + slot);
            const workingPrimaries = (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getPrimaries((0, $d5b85d29c0b78636$export$5e6fd513f44698c).workingColorSpace);
            const texturePrimaries = texture.colorSpace === (0, $d5b85d29c0b78636$export$bfcb490c2dd3db51) ? null : (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getPrimaries(texture.colorSpace);
            const unpackConversion = texture.colorSpace === (0, $d5b85d29c0b78636$export$bfcb490c2dd3db51) || workingPrimaries === texturePrimaries ? _gl.NONE : _gl.BROWSER_DEFAULT_WEBGL;
            _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, texture.flipY);
            _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha);
            _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, texture.unpackAlignment);
            _gl.pixelStorei(_gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, unpackConversion);
            const isCompressed = texture.isCompressedTexture || texture.image[0].isCompressedTexture;
            const isDataTexture = texture.image[0] && texture.image[0].isDataTexture;
            const cubeImage = [];
            for(let i = 0; i < 6; i++){
                if (!isCompressed && !isDataTexture) cubeImage[i] = resizeImage(texture.image[i], true, capabilities.maxCubemapSize);
                else cubeImage[i] = isDataTexture ? texture.image[i].image : texture.image[i];
                cubeImage[i] = verifyColorSpace(texture, cubeImage[i]);
            }
            const image = cubeImage[0], glFormat = utils.convert(texture.format, texture.colorSpace), glType = utils.convert(texture.type), glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace);
            const useTexStorage = texture.isVideoTexture !== true;
            const allocateMemory = sourceProperties.__version === undefined || forceUpload === true;
            const dataReady = source.dataReady;
            let levels = getMipLevels(texture, image);
            setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture);
            let mipmaps;
            if (isCompressed) {
                if (useTexStorage && allocateMemory) state.texStorage2D(_gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, image.width, image.height);
                for(let i = 0; i < 6; i++){
                    mipmaps = cubeImage[i].mipmaps;
                    for(let j = 0; j < mipmaps.length; j++){
                        const mipmap = mipmaps[j];
                        if (texture.format !== (0, $d5b85d29c0b78636$export$3f8bb04b555a363c)) {
                            if (glFormat !== null) {
                                if (useTexStorage) {
                                    if (dataReady) state.compressedTexSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, mipmap.data);
                                } else state.compressedTexImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data);
                            } else console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()');
                        } else {
                            if (useTexStorage) {
                                if (dataReady) state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, 0, 0, mipmap.width, mipmap.height, glFormat, glType, mipmap.data);
                            } else state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data);
                        }
                    }
                }
            } else {
                mipmaps = texture.mipmaps;
                if (useTexStorage && allocateMemory) {
                    // TODO: Uniformly handle mipmap definitions
                    // Normal textures and compressed cube textures define base level + mips with their mipmap array
                    // Uncompressed cube textures use their mipmap array only for mips (no base level)
                    if (mipmaps.length > 0) levels++;
                    const dimensions = getDimensions(cubeImage[0]);
                    state.texStorage2D(_gl.TEXTURE_CUBE_MAP, levels, glInternalFormat, dimensions.width, dimensions.height);
                }
                for(let i = 0; i < 6; i++)if (isDataTexture) {
                    if (useTexStorage) {
                        if (dataReady) state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, cubeImage[i].width, cubeImage[i].height, glFormat, glType, cubeImage[i].data);
                    } else state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, cubeImage[i].width, cubeImage[i].height, 0, glFormat, glType, cubeImage[i].data);
                    for(let j = 0; j < mipmaps.length; j++){
                        const mipmap = mipmaps[j];
                        const mipmapImage = mipmap.image[i].image;
                        if (useTexStorage) {
                            if (dataReady) state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, mipmapImage.width, mipmapImage.height, glFormat, glType, mipmapImage.data);
                        } else state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data);
                    }
                } else {
                    if (useTexStorage) {
                        if (dataReady) state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, 0, 0, glFormat, glType, cubeImage[i]);
                    } else state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, glFormat, glType, cubeImage[i]);
                    for(let j = 0; j < mipmaps.length; j++){
                        const mipmap = mipmaps[j];
                        if (useTexStorage) {
                            if (dataReady) state.texSubImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, 0, 0, glFormat, glType, mipmap.image[i]);
                        } else state.texImage2D(_gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j + 1, glInternalFormat, glFormat, glType, mipmap.image[i]);
                    }
                }
            }
            if (textureNeedsGenerateMipmaps(texture)) // We assume images for cube map have the same size.
            generateMipmap(_gl.TEXTURE_CUBE_MAP);
            sourceProperties.__version = source.version;
            if (texture.onUpdate) texture.onUpdate(texture);
        }
        textureProperties.__version = texture.version;
    }
    // Render targets
    // Setup storage for target texture and bind it to correct framebuffer
    function setupFrameBufferTexture(framebuffer, renderTarget, texture, attachment, textureTarget, level) {
        const glFormat = utils.convert(texture.format, texture.colorSpace);
        const glType = utils.convert(texture.type);
        const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace);
        const renderTargetProperties = properties.get(renderTarget);
        const textureProperties = properties.get(texture);
        textureProperties.__renderTarget = renderTarget;
        if (!renderTargetProperties.__hasExternalTextures) {
            const width = Math.max(1, renderTarget.width >> level);
            const height = Math.max(1, renderTarget.height >> level);
            if (textureTarget === _gl.TEXTURE_3D || textureTarget === _gl.TEXTURE_2D_ARRAY) state.texImage3D(textureTarget, level, glInternalFormat, width, height, renderTarget.depth, 0, glFormat, glType, null);
            else state.texImage2D(textureTarget, level, glInternalFormat, width, height, 0, glFormat, glType, null);
        }
        state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
        if (useMultisampledRTT(renderTarget)) multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, attachment, textureTarget, textureProperties.__webglTexture, 0, getRenderTargetSamples(renderTarget));
        else if (textureTarget === _gl.TEXTURE_2D || textureTarget >= _gl.TEXTURE_CUBE_MAP_POSITIVE_X && textureTarget <= _gl.TEXTURE_CUBE_MAP_NEGATIVE_Z) _gl.framebufferTexture2D(_gl.FRAMEBUFFER, attachment, textureTarget, textureProperties.__webglTexture, level);
        state.bindFramebuffer(_gl.FRAMEBUFFER, null);
    }
    // Setup storage for internal depth/stencil buffers and bind to correct framebuffer
    function setupRenderBufferStorage(renderbuffer, renderTarget, isMultisample) {
        _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer);
        if (renderTarget.depthBuffer) {
            // retrieve the depth attachment types
            const depthTexture = renderTarget.depthTexture;
            const depthType = depthTexture && depthTexture.isDepthTexture ? depthTexture.type : null;
            const glInternalFormat = getInternalDepthFormat(renderTarget.stencilBuffer, depthType);
            const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
            // set up the attachment
            const samples = getRenderTargetSamples(renderTarget);
            const isUseMultisampledRTT = useMultisampledRTT(renderTarget);
            if (isUseMultisampledRTT) multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
            else if (isMultisample) _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
            else _gl.renderbufferStorage(_gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height);
            _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer);
        } else {
            const textures = renderTarget.textures;
            for(let i = 0; i < textures.length; i++){
                const texture = textures[i];
                const glFormat = utils.convert(texture.format, texture.colorSpace);
                const glType = utils.convert(texture.type);
                const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace);
                const samples = getRenderTargetSamples(renderTarget);
                if (isMultisample && useMultisampledRTT(renderTarget) === false) _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
                else if (useMultisampledRTT(renderTarget)) multisampledRTTExt.renderbufferStorageMultisampleEXT(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
                else _gl.renderbufferStorage(_gl.RENDERBUFFER, glInternalFormat, renderTarget.width, renderTarget.height);
            }
        }
        _gl.bindRenderbuffer(_gl.RENDERBUFFER, null);
    }
    // Setup resources for a Depth Texture for a FBO (needs an extension)
    function setupDepthTexture(framebuffer, renderTarget) {
        const isCube = renderTarget && renderTarget.isWebGLCubeRenderTarget;
        if (isCube) throw new Error('Depth Texture with cube render targets is not supported');
        state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
        if (!(renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture)) throw new Error('renderTarget.depthTexture must be an instance of THREE.DepthTexture');
        const textureProperties = properties.get(renderTarget.depthTexture);
        textureProperties.__renderTarget = renderTarget;
        // upload an empty depth texture with framebuffer size
        if (!textureProperties.__webglTexture || renderTarget.depthTexture.image.width !== renderTarget.width || renderTarget.depthTexture.image.height !== renderTarget.height) {
            renderTarget.depthTexture.image.width = renderTarget.width;
            renderTarget.depthTexture.image.height = renderTarget.height;
            renderTarget.depthTexture.needsUpdate = true;
        }
        setTexture2D(renderTarget.depthTexture, 0);
        const webglDepthTexture = textureProperties.__webglTexture;
        const samples = getRenderTargetSamples(renderTarget);
        if (renderTarget.depthTexture.format === (0, $d5b85d29c0b78636$export$c1b6b5136be58045)) {
            if (useMultisampledRTT(renderTarget)) multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples);
            else _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0);
        } else if (renderTarget.depthTexture.format === (0, $d5b85d29c0b78636$export$1e113ac2d0905829)) {
            if (useMultisampledRTT(renderTarget)) multisampledRTTExt.framebufferTexture2DMultisampleEXT(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0, samples);
            else _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0);
        } else throw new Error('Unknown depthTexture format');
    }
    // Setup GL resources for a non-texture depth buffer
    function setupDepthRenderbuffer(renderTarget) {
        const renderTargetProperties = properties.get(renderTarget);
        const isCube = renderTarget.isWebGLCubeRenderTarget === true;
        // if the bound depth texture has changed
        if (renderTargetProperties.__boundDepthTexture !== renderTarget.depthTexture) {
            // fire the dispose event to get rid of stored state associated with the previously bound depth buffer
            const depthTexture = renderTarget.depthTexture;
            if (renderTargetProperties.__depthDisposeCallback) renderTargetProperties.__depthDisposeCallback();
            // set up dispose listeners to track when the currently attached buffer is implicitly unbound
            if (depthTexture) {
                const disposeEvent = ()=>{
                    delete renderTargetProperties.__boundDepthTexture;
                    delete renderTargetProperties.__depthDisposeCallback;
                    depthTexture.removeEventListener('dispose', disposeEvent);
                };
                depthTexture.addEventListener('dispose', disposeEvent);
                renderTargetProperties.__depthDisposeCallback = disposeEvent;
            }
            renderTargetProperties.__boundDepthTexture = depthTexture;
        }
        if (renderTarget.depthTexture && !renderTargetProperties.__autoAllocateDepthBuffer) {
            if (isCube) throw new Error('target.depthTexture not supported in Cube render targets');
            setupDepthTexture(renderTargetProperties.__webglFramebuffer, renderTarget);
        } else if (isCube) {
            renderTargetProperties.__webglDepthbuffer = [];
            for(let i = 0; i < 6; i++){
                state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[i]);
                if (renderTargetProperties.__webglDepthbuffer[i] === undefined) {
                    renderTargetProperties.__webglDepthbuffer[i] = _gl.createRenderbuffer();
                    setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer[i], renderTarget, false);
                } else {
                    // attach buffer if it's been created already
                    const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
                    const renderbuffer = renderTargetProperties.__webglDepthbuffer[i];
                    _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer);
                    _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer);
                }
            }
        } else {
            state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
            if (renderTargetProperties.__webglDepthbuffer === undefined) {
                renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
                setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer, renderTarget, false);
            } else {
                // attach buffer if it's been created already
                const glAttachmentType = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
                const renderbuffer = renderTargetProperties.__webglDepthbuffer;
                _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderbuffer);
                _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, glAttachmentType, _gl.RENDERBUFFER, renderbuffer);
            }
        }
        state.bindFramebuffer(_gl.FRAMEBUFFER, null);
    }
    // rebind framebuffer with external textures
    function rebindTextures(renderTarget, colorTexture, depthTexture) {
        const renderTargetProperties = properties.get(renderTarget);
        if (colorTexture !== undefined) setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, renderTarget.texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, 0);
        if (depthTexture !== undefined) setupDepthRenderbuffer(renderTarget);
    }
    // Set up GL resources for the render target
    function setupRenderTarget(renderTarget) {
        const texture = renderTarget.texture;
        const renderTargetProperties = properties.get(renderTarget);
        const textureProperties = properties.get(texture);
        renderTarget.addEventListener('dispose', onRenderTargetDispose);
        const textures = renderTarget.textures;
        const isCube = renderTarget.isWebGLCubeRenderTarget === true;
        const isMultipleRenderTargets = textures.length > 1;
        if (!isMultipleRenderTargets) {
            if (textureProperties.__webglTexture === undefined) textureProperties.__webglTexture = _gl.createTexture();
            textureProperties.__version = texture.version;
            info.memory.textures++;
        }
        // Setup framebuffer
        if (isCube) {
            renderTargetProperties.__webglFramebuffer = [];
            for(let i = 0; i < 6; i++)if (texture.mipmaps && texture.mipmaps.length > 0) {
                renderTargetProperties.__webglFramebuffer[i] = [];
                for(let level = 0; level < texture.mipmaps.length; level++)renderTargetProperties.__webglFramebuffer[i][level] = _gl.createFramebuffer();
            } else renderTargetProperties.__webglFramebuffer[i] = _gl.createFramebuffer();
        } else {
            if (texture.mipmaps && texture.mipmaps.length > 0) {
                renderTargetProperties.__webglFramebuffer = [];
                for(let level = 0; level < texture.mipmaps.length; level++)renderTargetProperties.__webglFramebuffer[level] = _gl.createFramebuffer();
            } else renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();
            if (isMultipleRenderTargets) for(let i = 0, il = textures.length; i < il; i++){
                const attachmentProperties = properties.get(textures[i]);
                if (attachmentProperties.__webglTexture === undefined) {
                    attachmentProperties.__webglTexture = _gl.createTexture();
                    info.memory.textures++;
                }
            }
            if (renderTarget.samples > 0 && useMultisampledRTT(renderTarget) === false) {
                renderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer();
                renderTargetProperties.__webglColorRenderbuffer = [];
                state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
                for(let i = 0; i < textures.length; i++){
                    const texture = textures[i];
                    renderTargetProperties.__webglColorRenderbuffer[i] = _gl.createRenderbuffer();
                    _gl.bindRenderbuffer(_gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
                    const glFormat = utils.convert(texture.format, texture.colorSpace);
                    const glType = utils.convert(texture.type);
                    const glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType, texture.colorSpace, renderTarget.isXRRenderTarget === true);
                    const samples = getRenderTargetSamples(renderTarget);
                    _gl.renderbufferStorageMultisample(_gl.RENDERBUFFER, samples, glInternalFormat, renderTarget.width, renderTarget.height);
                    _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
                }
                _gl.bindRenderbuffer(_gl.RENDERBUFFER, null);
                if (renderTarget.depthBuffer) {
                    renderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer();
                    setupRenderBufferStorage(renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true);
                }
                state.bindFramebuffer(_gl.FRAMEBUFFER, null);
            }
        }
        // Setup color buffer
        if (isCube) {
            state.bindTexture(_gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture);
            setTextureParameters(_gl.TEXTURE_CUBE_MAP, texture);
            for(let i = 0; i < 6; i++){
                if (texture.mipmaps && texture.mipmaps.length > 0) for(let level = 0; level < texture.mipmaps.length; level++)setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[i][level], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, level);
                else setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[i], renderTarget, texture, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0);
            }
            if (textureNeedsGenerateMipmaps(texture)) generateMipmap(_gl.TEXTURE_CUBE_MAP);
            state.unbindTexture();
        } else if (isMultipleRenderTargets) {
            for(let i = 0, il = textures.length; i < il; i++){
                const attachment = textures[i];
                const attachmentProperties = properties.get(attachment);
                state.bindTexture(_gl.TEXTURE_2D, attachmentProperties.__webglTexture);
                setTextureParameters(_gl.TEXTURE_2D, attachment);
                setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, attachment, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, 0);
                if (textureNeedsGenerateMipmaps(attachment)) generateMipmap(_gl.TEXTURE_2D);
            }
            state.unbindTexture();
        } else {
            let glTextureType = _gl.TEXTURE_2D;
            if (renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget) glTextureType = renderTarget.isWebGL3DRenderTarget ? _gl.TEXTURE_3D : _gl.TEXTURE_2D_ARRAY;
            state.bindTexture(glTextureType, textureProperties.__webglTexture);
            setTextureParameters(glTextureType, texture);
            if (texture.mipmaps && texture.mipmaps.length > 0) for(let level = 0; level < texture.mipmaps.length; level++)setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[level], renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, level);
            else setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, texture, _gl.COLOR_ATTACHMENT0, glTextureType, 0);
            if (textureNeedsGenerateMipmaps(texture)) generateMipmap(glTextureType);
            state.unbindTexture();
        }
        // Setup depth and stencil buffers
        if (renderTarget.depthBuffer) setupDepthRenderbuffer(renderTarget);
    }
    function updateRenderTargetMipmap(renderTarget) {
        const textures = renderTarget.textures;
        for(let i = 0, il = textures.length; i < il; i++){
            const texture = textures[i];
            if (textureNeedsGenerateMipmaps(texture)) {
                const targetType = getTargetType(renderTarget);
                const webglTexture = properties.get(texture).__webglTexture;
                state.bindTexture(targetType, webglTexture);
                generateMipmap(targetType);
                state.unbindTexture();
            }
        }
    }
    const invalidationArrayRead = [];
    const invalidationArrayDraw = [];
    function updateMultisampleRenderTarget(renderTarget) {
        if (renderTarget.samples > 0) {
            if (useMultisampledRTT(renderTarget) === false) {
                const textures = renderTarget.textures;
                const width = renderTarget.width;
                const height = renderTarget.height;
                let mask = _gl.COLOR_BUFFER_BIT;
                const depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
                const renderTargetProperties = properties.get(renderTarget);
                const isMultipleRenderTargets = textures.length > 1;
                // If MRT we need to remove FBO attachments
                if (isMultipleRenderTargets) for(let i = 0; i < textures.length; i++){
                    state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
                    _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, null);
                    state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
                    _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, null, 0);
                }
                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
                for(let i = 0; i < textures.length; i++){
                    if (renderTarget.resolveDepthBuffer) {
                        if (renderTarget.depthBuffer) mask |= _gl.DEPTH_BUFFER_BIT;
                        // resolving stencil is slow with a D3D backend. disable it for all transmission render targets (see #27799)
                        if (renderTarget.stencilBuffer && renderTarget.resolveStencilBuffer) mask |= _gl.STENCIL_BUFFER_BIT;
                    }
                    if (isMultipleRenderTargets) {
                        _gl.framebufferRenderbuffer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
                        const webglTexture = properties.get(textures[i]).__webglTexture;
                        _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, webglTexture, 0);
                    }
                    _gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, mask, _gl.NEAREST);
                    if (supportsInvalidateFramebuffer === true) {
                        invalidationArrayRead.length = 0;
                        invalidationArrayDraw.length = 0;
                        invalidationArrayRead.push(_gl.COLOR_ATTACHMENT0 + i);
                        if (renderTarget.depthBuffer && renderTarget.resolveDepthBuffer === false) {
                            invalidationArrayRead.push(depthStyle);
                            invalidationArrayDraw.push(depthStyle);
                            _gl.invalidateFramebuffer(_gl.DRAW_FRAMEBUFFER, invalidationArrayDraw);
                        }
                        _gl.invalidateFramebuffer(_gl.READ_FRAMEBUFFER, invalidationArrayRead);
                    }
                }
                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null);
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null);
                // If MRT since pre-blit we removed the FBO we need to reconstruct the attachments
                if (isMultipleRenderTargets) for(let i = 0; i < textures.length; i++){
                    state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
                    _gl.framebufferRenderbuffer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.RENDERBUFFER, renderTargetProperties.__webglColorRenderbuffer[i]);
                    const webglTexture = properties.get(textures[i]).__webglTexture;
                    state.bindFramebuffer(_gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer);
                    _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0 + i, _gl.TEXTURE_2D, webglTexture, 0);
                }
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, renderTargetProperties.__webglMultisampledFramebuffer);
            } else if (renderTarget.depthBuffer && renderTarget.resolveDepthBuffer === false && supportsInvalidateFramebuffer) {
                const depthStyle = renderTarget.stencilBuffer ? _gl.DEPTH_STENCIL_ATTACHMENT : _gl.DEPTH_ATTACHMENT;
                _gl.invalidateFramebuffer(_gl.DRAW_FRAMEBUFFER, [
                    depthStyle
                ]);
            }
        }
    }
    function getRenderTargetSamples(renderTarget) {
        return Math.min(capabilities.maxSamples, renderTarget.samples);
    }
    function useMultisampledRTT(renderTarget) {
        const renderTargetProperties = properties.get(renderTarget);
        return renderTarget.samples > 0 && extensions.has('WEBGL_multisampled_render_to_texture') === true && renderTargetProperties.__useRenderToTexture !== false;
    }
    function updateVideoTexture(texture) {
        const frame = info.render.frame;
        // Check the last frame we updated the VideoTexture
        if (_videoTextures.get(texture) !== frame) {
            _videoTextures.set(texture, frame);
            texture.update();
        }
    }
    function verifyColorSpace(texture, image) {
        const colorSpace = texture.colorSpace;
        const format = texture.format;
        const type = texture.type;
        if (texture.isCompressedTexture === true || texture.isVideoTexture === true) return image;
        if (colorSpace !== (0, $d5b85d29c0b78636$export$42429b3acfb233a4) && colorSpace !== (0, $d5b85d29c0b78636$export$bfcb490c2dd3db51)) {
            // sRGB
            if ((0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(colorSpace) === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb)) // in WebGL 2 uncompressed textures can only be sRGB encoded if they have the RGBA8 format
            {
                if (format !== (0, $d5b85d29c0b78636$export$3f8bb04b555a363c) || type !== (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10)) console.warn('THREE.WebGLTextures: sRGB encoded textures have to use RGBAFormat and UnsignedByteType.');
            } else console.error('THREE.WebGLTextures: Unsupported texture color space:', colorSpace);
        }
        return image;
    }
    function getDimensions(image) {
        if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement) {
            // if intrinsic data are not available, fallback to width/height
            _imageDimensions.width = image.naturalWidth || image.width;
            _imageDimensions.height = image.naturalHeight || image.height;
        } else if (typeof VideoFrame !== 'undefined' && image instanceof VideoFrame) {
            _imageDimensions.width = image.displayWidth;
            _imageDimensions.height = image.displayHeight;
        } else {
            _imageDimensions.width = image.width;
            _imageDimensions.height = image.height;
        }
        return _imageDimensions;
    }
    //
    this.allocateTextureUnit = allocateTextureUnit;
    this.resetTextureUnits = resetTextureUnits;
    this.setTexture2D = setTexture2D;
    this.setTexture2DArray = setTexture2DArray;
    this.setTexture3D = setTexture3D;
    this.setTextureCube = setTextureCube;
    this.rebindTextures = rebindTextures;
    this.setupRenderTarget = setupRenderTarget;
    this.updateRenderTargetMipmap = updateRenderTargetMipmap;
    this.updateMultisampleRenderTarget = updateMultisampleRenderTarget;
    this.setupDepthRenderbuffer = setupDepthRenderbuffer;
    this.setupFrameBufferTexture = setupFrameBufferTexture;
    this.useMultisampledRTT = useMultisampledRTT;
}
function $3dd44ec8564e7230$export$ddaebcad857649a8(gl, extensions) {
    function convert(p, colorSpace = (0, $d5b85d29c0b78636$export$bfcb490c2dd3db51)) {
        let extension;
        const transfer = (0, $d5b85d29c0b78636$export$5e6fd513f44698c).getTransfer(colorSpace);
        if (p === (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10)) return gl.UNSIGNED_BYTE;
        if (p === (0, $d5b85d29c0b78636$export$b3969b01faf587f2)) return gl.UNSIGNED_SHORT_4_4_4_4;
        if (p === (0, $d5b85d29c0b78636$export$18886f8ae33e90de)) return gl.UNSIGNED_SHORT_5_5_5_1;
        if (p === (0, $d5b85d29c0b78636$export$5a4c329b7e2092d3)) return gl.UNSIGNED_INT_5_9_9_9_REV;
        if (p === (0, $d5b85d29c0b78636$export$545fce0311a9796a)) return gl.BYTE;
        if (p === (0, $d5b85d29c0b78636$export$88572337f312435f)) return gl.SHORT;
        if (p === (0, $d5b85d29c0b78636$export$c63dc51868b06a9d)) return gl.UNSIGNED_SHORT;
        if (p === (0, $d5b85d29c0b78636$export$5c612977753abe2)) return gl.INT;
        if (p === (0, $d5b85d29c0b78636$export$c3c7fc4518ebba96)) return gl.UNSIGNED_INT;
        if (p === (0, $d5b85d29c0b78636$export$f6d331659b644596)) return gl.FLOAT;
        if (p === (0, $d5b85d29c0b78636$export$2697304443f382bc)) return gl.HALF_FLOAT;
        if (p === (0, $d5b85d29c0b78636$export$988473390501ed4b)) return gl.ALPHA;
        if (p === (0, $d5b85d29c0b78636$export$7c67423a5ee6f5eb)) return gl.RGB;
        if (p === (0, $d5b85d29c0b78636$export$3f8bb04b555a363c)) return gl.RGBA;
        if (p === (0, $d5b85d29c0b78636$export$cc09ccbf6d1ed449)) return gl.LUMINANCE;
        if (p === (0, $d5b85d29c0b78636$export$9053a81c4a69c289)) return gl.LUMINANCE_ALPHA;
        if (p === (0, $d5b85d29c0b78636$export$c1b6b5136be58045)) return gl.DEPTH_COMPONENT;
        if (p === (0, $d5b85d29c0b78636$export$1e113ac2d0905829)) return gl.DEPTH_STENCIL;
        // WebGL2 formats.
        if (p === (0, $d5b85d29c0b78636$export$4e041a7967d15c4b)) return gl.RED;
        if (p === (0, $d5b85d29c0b78636$export$aa92e870a709d190)) return gl.RED_INTEGER;
        if (p === (0, $d5b85d29c0b78636$export$6cdf0b461c7ce8a0)) return gl.RG;
        if (p === (0, $d5b85d29c0b78636$export$1ba1c45f9f77d4d7)) return gl.RG_INTEGER;
        if (p === (0, $d5b85d29c0b78636$export$c200e7d26f592f21)) return gl.RGBA_INTEGER;
        // S3TC
        if (p === (0, $d5b85d29c0b78636$export$21d1799c6d552fc0) || p === (0, $d5b85d29c0b78636$export$afa304c3e981b668) || p === (0, $d5b85d29c0b78636$export$d2a1a68024a3e56c) || p === (0, $d5b85d29c0b78636$export$9a79c424327dacf9)) {
            if (transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb)) {
                extension = extensions.get('WEBGL_compressed_texture_s3tc_srgb');
                if (extension !== null) {
                    if (p === (0, $d5b85d29c0b78636$export$21d1799c6d552fc0)) return extension.COMPRESSED_SRGB_S3TC_DXT1_EXT;
                    if (p === (0, $d5b85d29c0b78636$export$afa304c3e981b668)) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
                    if (p === (0, $d5b85d29c0b78636$export$d2a1a68024a3e56c)) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
                    if (p === (0, $d5b85d29c0b78636$export$9a79c424327dacf9)) return extension.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
                } else return null;
            } else {
                extension = extensions.get('WEBGL_compressed_texture_s3tc');
                if (extension !== null) {
                    if (p === (0, $d5b85d29c0b78636$export$21d1799c6d552fc0)) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
                    if (p === (0, $d5b85d29c0b78636$export$afa304c3e981b668)) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
                    if (p === (0, $d5b85d29c0b78636$export$d2a1a68024a3e56c)) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
                    if (p === (0, $d5b85d29c0b78636$export$9a79c424327dacf9)) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
                } else return null;
            }
        }
        // PVRTC
        if (p === (0, $d5b85d29c0b78636$export$19ada9bbb1af3573) || p === (0, $d5b85d29c0b78636$export$d0f0355bb3d948e4) || p === (0, $d5b85d29c0b78636$export$b82296714358084c) || p === (0, $d5b85d29c0b78636$export$b71692456c47b6c3)) {
            extension = extensions.get('WEBGL_compressed_texture_pvrtc');
            if (extension !== null) {
                if (p === (0, $d5b85d29c0b78636$export$19ada9bbb1af3573)) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
                if (p === (0, $d5b85d29c0b78636$export$d0f0355bb3d948e4)) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
                if (p === (0, $d5b85d29c0b78636$export$b82296714358084c)) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
                if (p === (0, $d5b85d29c0b78636$export$b71692456c47b6c3)) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
            } else return null;
        }
        // ETC
        if (p === (0, $d5b85d29c0b78636$export$6ab91af2d757aee7) || p === (0, $d5b85d29c0b78636$export$7800993ef8106a6a) || p === (0, $d5b85d29c0b78636$export$23ed8300a860e7d8)) {
            extension = extensions.get('WEBGL_compressed_texture_etc');
            if (extension !== null) {
                if (p === (0, $d5b85d29c0b78636$export$6ab91af2d757aee7) || p === (0, $d5b85d29c0b78636$export$7800993ef8106a6a)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ETC2 : extension.COMPRESSED_RGB8_ETC2;
                if (p === (0, $d5b85d29c0b78636$export$23ed8300a860e7d8)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : extension.COMPRESSED_RGBA8_ETC2_EAC;
            } else return null;
        }
        // ASTC
        if (p === (0, $d5b85d29c0b78636$export$dc5570b4a2b92d48) || p === (0, $d5b85d29c0b78636$export$68880cd325f8b2fb) || p === (0, $d5b85d29c0b78636$export$7d2c0be323373d95) || p === (0, $d5b85d29c0b78636$export$22b52da301fc3a3e) || p === (0, $d5b85d29c0b78636$export$c009e2cb4a66485e) || p === (0, $d5b85d29c0b78636$export$118fff5afa255b63) || p === (0, $d5b85d29c0b78636$export$120713c829ae0667) || p === (0, $d5b85d29c0b78636$export$c79eeabbf53313e9) || p === (0, $d5b85d29c0b78636$export$443cf6567cdd6424) || p === (0, $d5b85d29c0b78636$export$6573984fc9840780) || p === (0, $d5b85d29c0b78636$export$e7aee563f30091de) || p === (0, $d5b85d29c0b78636$export$2eb8634622ddeab7) || p === (0, $d5b85d29c0b78636$export$202b1ce7b5d25742) || p === (0, $d5b85d29c0b78636$export$18ab77abd087e467)) {
            extension = extensions.get('WEBGL_compressed_texture_astc');
            if (extension !== null) {
                if (p === (0, $d5b85d29c0b78636$export$dc5570b4a2b92d48)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : extension.COMPRESSED_RGBA_ASTC_4x4_KHR;
                if (p === (0, $d5b85d29c0b78636$export$68880cd325f8b2fb)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : extension.COMPRESSED_RGBA_ASTC_5x4_KHR;
                if (p === (0, $d5b85d29c0b78636$export$7d2c0be323373d95)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : extension.COMPRESSED_RGBA_ASTC_5x5_KHR;
                if (p === (0, $d5b85d29c0b78636$export$22b52da301fc3a3e)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : extension.COMPRESSED_RGBA_ASTC_6x5_KHR;
                if (p === (0, $d5b85d29c0b78636$export$c009e2cb4a66485e)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : extension.COMPRESSED_RGBA_ASTC_6x6_KHR;
                if (p === (0, $d5b85d29c0b78636$export$118fff5afa255b63)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : extension.COMPRESSED_RGBA_ASTC_8x5_KHR;
                if (p === (0, $d5b85d29c0b78636$export$120713c829ae0667)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : extension.COMPRESSED_RGBA_ASTC_8x6_KHR;
                if (p === (0, $d5b85d29c0b78636$export$c79eeabbf53313e9)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : extension.COMPRESSED_RGBA_ASTC_8x8_KHR;
                if (p === (0, $d5b85d29c0b78636$export$443cf6567cdd6424)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : extension.COMPRESSED_RGBA_ASTC_10x5_KHR;
                if (p === (0, $d5b85d29c0b78636$export$6573984fc9840780)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : extension.COMPRESSED_RGBA_ASTC_10x6_KHR;
                if (p === (0, $d5b85d29c0b78636$export$e7aee563f30091de)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : extension.COMPRESSED_RGBA_ASTC_10x8_KHR;
                if (p === (0, $d5b85d29c0b78636$export$2eb8634622ddeab7)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : extension.COMPRESSED_RGBA_ASTC_10x10_KHR;
                if (p === (0, $d5b85d29c0b78636$export$202b1ce7b5d25742)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : extension.COMPRESSED_RGBA_ASTC_12x10_KHR;
                if (p === (0, $d5b85d29c0b78636$export$18ab77abd087e467)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : extension.COMPRESSED_RGBA_ASTC_12x12_KHR;
            } else return null;
        }
        // BPTC
        if (p === (0, $d5b85d29c0b78636$export$ce40b115e188bc81) || p === (0, $d5b85d29c0b78636$export$d279c5c4bac5121e) || p === (0, $d5b85d29c0b78636$export$cde52d17225fdbd3)) {
            extension = extensions.get('EXT_texture_compression_bptc');
            if (extension !== null) {
                if (p === (0, $d5b85d29c0b78636$export$ce40b115e188bc81)) return transfer === (0, $d5b85d29c0b78636$export$8d0a61916cc26abb) ? extension.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT : extension.COMPRESSED_RGBA_BPTC_UNORM_EXT;
                if (p === (0, $d5b85d29c0b78636$export$d279c5c4bac5121e)) return extension.COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT;
                if (p === (0, $d5b85d29c0b78636$export$cde52d17225fdbd3)) return extension.COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT;
            } else return null;
        }
        // RGTC
        if (p === (0, $d5b85d29c0b78636$export$b1688df4c4c21670) || p === (0, $d5b85d29c0b78636$export$fc15e5d8261eed58) || p === (0, $d5b85d29c0b78636$export$d220f6ade8463a0f) || p === (0, $d5b85d29c0b78636$export$768646d09dc1b6ef)) {
            extension = extensions.get('EXT_texture_compression_rgtc');
            if (extension !== null) {
                if (p === (0, $d5b85d29c0b78636$export$ce40b115e188bc81)) return extension.COMPRESSED_RED_RGTC1_EXT;
                if (p === (0, $d5b85d29c0b78636$export$fc15e5d8261eed58)) return extension.COMPRESSED_SIGNED_RED_RGTC1_EXT;
                if (p === (0, $d5b85d29c0b78636$export$d220f6ade8463a0f)) return extension.COMPRESSED_RED_GREEN_RGTC2_EXT;
                if (p === (0, $d5b85d29c0b78636$export$768646d09dc1b6ef)) return extension.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT;
            } else return null;
        }
        //
        if (p === (0, $d5b85d29c0b78636$export$6c8ea339bfab1301)) return gl.UNSIGNED_INT_24_8;
        // if "p" can't be resolved, assume the user defines a WebGL constant as a string (fallback/workaround for packed RGB formats)
        return gl[p] !== undefined ? gl[p] : null;
    }
    return {
        convert: convert
    };
}
const $3dd44ec8564e7230$var$_moveEvent = {
    type: 'move'
};
class $3dd44ec8564e7230$var$WebXRController {
    constructor(){
        this._targetRay = null;
        this._grip = null;
        this._hand = null;
    }
    getHandSpace() {
        if (this._hand === null) {
            this._hand = new (0, $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4)();
            this._hand.matrixAutoUpdate = false;
            this._hand.visible = false;
            this._hand.joints = {};
            this._hand.inputState = {
                pinching: false
            };
        }
        return this._hand;
    }
    getTargetRaySpace() {
        if (this._targetRay === null) {
            this._targetRay = new (0, $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4)();
            this._targetRay.matrixAutoUpdate = false;
            this._targetRay.visible = false;
            this._targetRay.hasLinearVelocity = false;
            this._targetRay.linearVelocity = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
            this._targetRay.hasAngularVelocity = false;
            this._targetRay.angularVelocity = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        }
        return this._targetRay;
    }
    getGripSpace() {
        if (this._grip === null) {
            this._grip = new (0, $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4)();
            this._grip.matrixAutoUpdate = false;
            this._grip.visible = false;
            this._grip.hasLinearVelocity = false;
            this._grip.linearVelocity = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
            this._grip.hasAngularVelocity = false;
            this._grip.angularVelocity = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        }
        return this._grip;
    }
    dispatchEvent(event) {
        if (this._targetRay !== null) this._targetRay.dispatchEvent(event);
        if (this._grip !== null) this._grip.dispatchEvent(event);
        if (this._hand !== null) this._hand.dispatchEvent(event);
        return this;
    }
    connect(inputSource) {
        if (inputSource && inputSource.hand) {
            const hand = this._hand;
            if (hand) for (const inputjoint of inputSource.hand.values())// Initialize hand with joints when connected
            this._getHandJoint(hand, inputjoint);
        }
        this.dispatchEvent({
            type: 'connected',
            data: inputSource
        });
        return this;
    }
    disconnect(inputSource) {
        this.dispatchEvent({
            type: 'disconnected',
            data: inputSource
        });
        if (this._targetRay !== null) this._targetRay.visible = false;
        if (this._grip !== null) this._grip.visible = false;
        if (this._hand !== null) this._hand.visible = false;
        return this;
    }
    update(inputSource, frame, referenceSpace) {
        let inputPose = null;
        let gripPose = null;
        let handPose = null;
        const targetRay = this._targetRay;
        const grip = this._grip;
        const hand = this._hand;
        if (inputSource && frame.session.visibilityState !== 'visible-blurred') {
            if (hand && inputSource.hand) {
                handPose = true;
                for (const inputjoint of inputSource.hand.values()){
                    // Update the joints groups with the XRJoint poses
                    const jointPose = frame.getJointPose(inputjoint, referenceSpace);
                    // The transform of this joint will be updated with the joint pose on each frame
                    const joint = this._getHandJoint(hand, inputjoint);
                    if (jointPose !== null) {
                        joint.matrix.fromArray(jointPose.transform.matrix);
                        joint.matrix.decompose(joint.position, joint.rotation, joint.scale);
                        joint.matrixWorldNeedsUpdate = true;
                        joint.jointRadius = jointPose.radius;
                    }
                    joint.visible = jointPose !== null;
                }
                // Custom events
                // Check pinchz
                const indexTip = hand.joints['index-finger-tip'];
                const thumbTip = hand.joints['thumb-tip'];
                const distance = indexTip.position.distanceTo(thumbTip.position);
                const distanceToPinch = 0.02;
                const threshold = 0.005;
                if (hand.inputState.pinching && distance > distanceToPinch + threshold) {
                    hand.inputState.pinching = false;
                    this.dispatchEvent({
                        type: 'pinchend',
                        handedness: inputSource.handedness,
                        target: this
                    });
                } else if (!hand.inputState.pinching && distance <= distanceToPinch - threshold) {
                    hand.inputState.pinching = true;
                    this.dispatchEvent({
                        type: 'pinchstart',
                        handedness: inputSource.handedness,
                        target: this
                    });
                }
            } else if (grip !== null && inputSource.gripSpace) {
                gripPose = frame.getPose(inputSource.gripSpace, referenceSpace);
                if (gripPose !== null) {
                    grip.matrix.fromArray(gripPose.transform.matrix);
                    grip.matrix.decompose(grip.position, grip.rotation, grip.scale);
                    grip.matrixWorldNeedsUpdate = true;
                    if (gripPose.linearVelocity) {
                        grip.hasLinearVelocity = true;
                        grip.linearVelocity.copy(gripPose.linearVelocity);
                    } else grip.hasLinearVelocity = false;
                    if (gripPose.angularVelocity) {
                        grip.hasAngularVelocity = true;
                        grip.angularVelocity.copy(gripPose.angularVelocity);
                    } else grip.hasAngularVelocity = false;
                }
            }
            if (targetRay !== null) {
                inputPose = frame.getPose(inputSource.targetRaySpace, referenceSpace);
                // Some runtimes (namely Vive Cosmos with Vive OpenXR Runtime) have only grip space and ray space is equal to it
                if (inputPose === null && gripPose !== null) inputPose = gripPose;
                if (inputPose !== null) {
                    targetRay.matrix.fromArray(inputPose.transform.matrix);
                    targetRay.matrix.decompose(targetRay.position, targetRay.rotation, targetRay.scale);
                    targetRay.matrixWorldNeedsUpdate = true;
                    if (inputPose.linearVelocity) {
                        targetRay.hasLinearVelocity = true;
                        targetRay.linearVelocity.copy(inputPose.linearVelocity);
                    } else targetRay.hasLinearVelocity = false;
                    if (inputPose.angularVelocity) {
                        targetRay.hasAngularVelocity = true;
                        targetRay.angularVelocity.copy(inputPose.angularVelocity);
                    } else targetRay.hasAngularVelocity = false;
                    this.dispatchEvent($3dd44ec8564e7230$var$_moveEvent);
                }
            }
        }
        if (targetRay !== null) targetRay.visible = inputPose !== null;
        if (grip !== null) grip.visible = gripPose !== null;
        if (hand !== null) hand.visible = handPose !== null;
        return this;
    }
    // private method
    _getHandJoint(hand, inputjoint) {
        if (hand.joints[inputjoint.jointName] === undefined) {
            const joint = new (0, $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4)();
            joint.matrixAutoUpdate = false;
            joint.visible = false;
            hand.joints[inputjoint.jointName] = joint;
            hand.add(joint);
        }
        return hand.joints[inputjoint.jointName];
    }
}
const $3dd44ec8564e7230$var$_occlusion_vertex = `
void main() {

	gl_Position = vec4( position, 1.0 );

}`;
const $3dd44ec8564e7230$var$_occlusion_fragment = `
uniform sampler2DArray depthColor;
uniform float depthWidth;
uniform float depthHeight;

void main() {

	vec2 coord = vec2( gl_FragCoord.x / depthWidth, gl_FragCoord.y / depthHeight );

	if ( coord.x >= 1.0 ) {

		gl_FragDepth = texture( depthColor, vec3( coord.x - 1.0, coord.y, 1 ) ).r;

	} else {

		gl_FragDepth = texture( depthColor, vec3( coord.x, coord.y, 0 ) ).r;

	}

}`;
class $3dd44ec8564e7230$var$WebXRDepthSensing {
    constructor(){
        this.texture = null;
        this.mesh = null;
        this.depthNear = 0;
        this.depthFar = 0;
    }
    init(renderer, depthData, renderState) {
        if (this.texture === null) {
            const texture = new (0, $d5b85d29c0b78636$export$5431306cf43de24a)();
            const texProps = renderer.properties.get(texture);
            texProps.__webglTexture = depthData.texture;
            if (depthData.depthNear !== renderState.depthNear || depthData.depthFar !== renderState.depthFar) {
                this.depthNear = depthData.depthNear;
                this.depthFar = depthData.depthFar;
            }
            this.texture = texture;
        }
    }
    getMesh(cameraXR) {
        if (this.texture !== null) {
            if (this.mesh === null) {
                const viewport = cameraXR.cameras[0].viewport;
                const material = new (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d)({
                    vertexShader: $3dd44ec8564e7230$var$_occlusion_vertex,
                    fragmentShader: $3dd44ec8564e7230$var$_occlusion_fragment,
                    uniforms: {
                        depthColor: {
                            value: this.texture
                        },
                        depthWidth: {
                            value: viewport.z
                        },
                        depthHeight: {
                            value: viewport.w
                        }
                    }
                });
                this.mesh = new (0, $d5b85d29c0b78636$export$e176487c05830cc5)(new (0, $d5b85d29c0b78636$export$967d831af31f69ce)(20, 20), material);
            }
        }
        return this.mesh;
    }
    reset() {
        this.texture = null;
        this.mesh = null;
    }
    getDepthTexture() {
        return this.texture;
    }
}
class $3dd44ec8564e7230$var$WebXRManager extends (0, $d5b85d29c0b78636$export$ec8b666c5fe2c75a) {
    constructor(renderer, gl){
        super();
        const scope = this;
        let session = null;
        let framebufferScaleFactor = 1.0;
        let referenceSpace = null;
        let referenceSpaceType = 'local-floor';
        // Set default foveation to maximum.
        let foveation = 1.0;
        let customReferenceSpace = null;
        let pose = null;
        let glBinding = null;
        let glProjLayer = null;
        let glBaseLayer = null;
        let xrFrame = null;
        const depthSensing = new $3dd44ec8564e7230$var$WebXRDepthSensing();
        const attributes = gl.getContextAttributes();
        let initialRenderTarget = null;
        let newRenderTarget = null;
        const controllers = [];
        const controllerInputSources = [];
        const currentSize = new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)();
        let currentPixelRatio = null;
        //
        const cameraL = new (0, $d5b85d29c0b78636$export$74e4ae24825f68d7)();
        cameraL.viewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
        const cameraR = new (0, $d5b85d29c0b78636$export$74e4ae24825f68d7)();
        cameraR.viewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
        const cameras = [
            cameraL,
            cameraR
        ];
        const cameraXR = new (0, $d5b85d29c0b78636$export$56b937d9e5581166)();
        let _currentDepthNear = null;
        let _currentDepthFar = null;
        //
        this.cameraAutoUpdate = true;
        this.enabled = false;
        this.isPresenting = false;
        this.getController = function(index) {
            let controller = controllers[index];
            if (controller === undefined) {
                controller = new $3dd44ec8564e7230$var$WebXRController();
                controllers[index] = controller;
            }
            return controller.getTargetRaySpace();
        };
        this.getControllerGrip = function(index) {
            let controller = controllers[index];
            if (controller === undefined) {
                controller = new $3dd44ec8564e7230$var$WebXRController();
                controllers[index] = controller;
            }
            return controller.getGripSpace();
        };
        this.getHand = function(index) {
            let controller = controllers[index];
            if (controller === undefined) {
                controller = new $3dd44ec8564e7230$var$WebXRController();
                controllers[index] = controller;
            }
            return controller.getHandSpace();
        };
        //
        function onSessionEvent(event) {
            const controllerIndex = controllerInputSources.indexOf(event.inputSource);
            if (controllerIndex === -1) return;
            const controller = controllers[controllerIndex];
            if (controller !== undefined) {
                controller.update(event.inputSource, event.frame, customReferenceSpace || referenceSpace);
                controller.dispatchEvent({
                    type: event.type,
                    data: event.inputSource
                });
            }
        }
        function onSessionEnd() {
            session.removeEventListener('select', onSessionEvent);
            session.removeEventListener('selectstart', onSessionEvent);
            session.removeEventListener('selectend', onSessionEvent);
            session.removeEventListener('squeeze', onSessionEvent);
            session.removeEventListener('squeezestart', onSessionEvent);
            session.removeEventListener('squeezeend', onSessionEvent);
            session.removeEventListener('end', onSessionEnd);
            session.removeEventListener('inputsourceschange', onInputSourcesChange);
            for(let i = 0; i < controllers.length; i++){
                const inputSource = controllerInputSources[i];
                if (inputSource === null) continue;
                controllerInputSources[i] = null;
                controllers[i].disconnect(inputSource);
            }
            _currentDepthNear = null;
            _currentDepthFar = null;
            depthSensing.reset();
            // restore framebuffer/rendering state
            renderer.setRenderTarget(initialRenderTarget);
            glBaseLayer = null;
            glProjLayer = null;
            glBinding = null;
            session = null;
            newRenderTarget = null;
            //
            animation.stop();
            scope.isPresenting = false;
            renderer.setPixelRatio(currentPixelRatio);
            renderer.setSize(currentSize.width, currentSize.height, false);
            scope.dispatchEvent({
                type: 'sessionend'
            });
        }
        this.setFramebufferScaleFactor = function(value) {
            framebufferScaleFactor = value;
            if (scope.isPresenting === true) console.warn('THREE.WebXRManager: Cannot change framebuffer scale while presenting.');
        };
        this.setReferenceSpaceType = function(value) {
            referenceSpaceType = value;
            if (scope.isPresenting === true) console.warn('THREE.WebXRManager: Cannot change reference space type while presenting.');
        };
        this.getReferenceSpace = function() {
            return customReferenceSpace || referenceSpace;
        };
        this.setReferenceSpace = function(space) {
            customReferenceSpace = space;
        };
        this.getBaseLayer = function() {
            return glProjLayer !== null ? glProjLayer : glBaseLayer;
        };
        this.getBinding = function() {
            return glBinding;
        };
        this.getFrame = function() {
            return xrFrame;
        };
        this.getSession = function() {
            return session;
        };
        this.setSession = async function(value) {
            session = value;
            if (session !== null) {
                initialRenderTarget = renderer.getRenderTarget();
                session.addEventListener('select', onSessionEvent);
                session.addEventListener('selectstart', onSessionEvent);
                session.addEventListener('selectend', onSessionEvent);
                session.addEventListener('squeeze', onSessionEvent);
                session.addEventListener('squeezestart', onSessionEvent);
                session.addEventListener('squeezeend', onSessionEvent);
                session.addEventListener('end', onSessionEnd);
                session.addEventListener('inputsourceschange', onInputSourcesChange);
                if (attributes.xrCompatible !== true) await gl.makeXRCompatible();
                currentPixelRatio = renderer.getPixelRatio();
                renderer.getSize(currentSize);
                const useLayers = session.enabledFeatures !== undefined && session.enabledFeatures.includes('layers');
                if (!useLayers) {
                    const layerInit = {
                        antialias: attributes.antialias,
                        alpha: true,
                        depth: attributes.depth,
                        stencil: attributes.stencil,
                        framebufferScaleFactor: framebufferScaleFactor
                    };
                    glBaseLayer = new XRWebGLLayer(session, gl, layerInit);
                    session.updateRenderState({
                        baseLayer: glBaseLayer
                    });
                    renderer.setPixelRatio(1);
                    renderer.setSize(glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, false);
                    newRenderTarget = new (0, $d5b85d29c0b78636$export$3c052beb2e51e23f)(glBaseLayer.framebufferWidth, glBaseLayer.framebufferHeight, {
                        format: (0, $d5b85d29c0b78636$export$3f8bb04b555a363c),
                        type: (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10),
                        colorSpace: renderer.outputColorSpace,
                        stencilBuffer: attributes.stencil
                    });
                } else {
                    let depthFormat = null;
                    let depthType = null;
                    let glDepthFormat = null;
                    if (attributes.depth) {
                        glDepthFormat = attributes.stencil ? gl.DEPTH24_STENCIL8 : gl.DEPTH_COMPONENT24;
                        depthFormat = attributes.stencil ? (0, $d5b85d29c0b78636$export$1e113ac2d0905829) : (0, $d5b85d29c0b78636$export$c1b6b5136be58045);
                        depthType = attributes.stencil ? (0, $d5b85d29c0b78636$export$6c8ea339bfab1301) : (0, $d5b85d29c0b78636$export$c3c7fc4518ebba96);
                    }
                    const projectionlayerInit = {
                        colorFormat: gl.RGBA8,
                        depthFormat: glDepthFormat,
                        scaleFactor: framebufferScaleFactor
                    };
                    glBinding = new XRWebGLBinding(session, gl);
                    glProjLayer = glBinding.createProjectionLayer(projectionlayerInit);
                    session.updateRenderState({
                        layers: [
                            glProjLayer
                        ]
                    });
                    renderer.setPixelRatio(1);
                    renderer.setSize(glProjLayer.textureWidth, glProjLayer.textureHeight, false);
                    newRenderTarget = new (0, $d5b85d29c0b78636$export$3c052beb2e51e23f)(glProjLayer.textureWidth, glProjLayer.textureHeight, {
                        format: (0, $d5b85d29c0b78636$export$3f8bb04b555a363c),
                        type: (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10),
                        depthTexture: new (0, $d5b85d29c0b78636$export$fc830aa069cc8c2f)(glProjLayer.textureWidth, glProjLayer.textureHeight, depthType, undefined, undefined, undefined, undefined, undefined, undefined, depthFormat),
                        stencilBuffer: attributes.stencil,
                        colorSpace: renderer.outputColorSpace,
                        samples: attributes.antialias ? 4 : 0,
                        resolveDepthBuffer: glProjLayer.ignoreDepthValues === false
                    });
                }
                newRenderTarget.isXRRenderTarget = true; // TODO Remove this when possible, see #23278
                this.setFoveation(foveation);
                customReferenceSpace = null;
                referenceSpace = await session.requestReferenceSpace(referenceSpaceType);
                animation.setContext(session);
                animation.start();
                scope.isPresenting = true;
                scope.dispatchEvent({
                    type: 'sessionstart'
                });
            }
        };
        this.getEnvironmentBlendMode = function() {
            if (session !== null) return session.environmentBlendMode;
        };
        this.getDepthTexture = function() {
            return depthSensing.getDepthTexture();
        };
        function onInputSourcesChange(event) {
            // Notify disconnected
            for(let i = 0; i < event.removed.length; i++){
                const inputSource = event.removed[i];
                const index = controllerInputSources.indexOf(inputSource);
                if (index >= 0) {
                    controllerInputSources[index] = null;
                    controllers[index].disconnect(inputSource);
                }
            }
            // Notify connected
            for(let i = 0; i < event.added.length; i++){
                const inputSource = event.added[i];
                let controllerIndex = controllerInputSources.indexOf(inputSource);
                if (controllerIndex === -1) {
                    // Assign input source a controller that currently has no input source
                    for(let i = 0; i < controllers.length; i++){
                        if (i >= controllerInputSources.length) {
                            controllerInputSources.push(inputSource);
                            controllerIndex = i;
                            break;
                        } else if (controllerInputSources[i] === null) {
                            controllerInputSources[i] = inputSource;
                            controllerIndex = i;
                            break;
                        }
                    }
                    // If all controllers do currently receive input we ignore new ones
                    if (controllerIndex === -1) break;
                }
                const controller = controllers[controllerIndex];
                if (controller) controller.connect(inputSource);
            }
        }
        //
        const cameraLPos = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        const cameraRPos = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        /**
		 * Assumes 2 cameras that are parallel and share an X-axis, and that
		 * the cameras' projection and world matrices have already been set.
		 * And that near and far planes are identical for both cameras.
		 * Visualization of this technique: https://computergraphics.stackexchange.com/a/4765
		 *
		 * @param {ArrayCamera} camera - The camera to update.
		 * @param {PerspectiveCamera} cameraL - The left camera.
		 * @param {PerspectiveCamera} cameraR - The right camera.
		 */ function setProjectionFromUnion(camera, cameraL, cameraR) {
            cameraLPos.setFromMatrixPosition(cameraL.matrixWorld);
            cameraRPos.setFromMatrixPosition(cameraR.matrixWorld);
            const ipd = cameraLPos.distanceTo(cameraRPos);
            const projL = cameraL.projectionMatrix.elements;
            const projR = cameraR.projectionMatrix.elements;
            // VR systems will have identical far and near planes, and
            // most likely identical top and bottom frustum extents.
            // Use the left camera for these values.
            const near = projL[14] / (projL[10] - 1);
            const far = projL[14] / (projL[10] + 1);
            const topFov = (projL[9] + 1) / projL[5];
            const bottomFov = (projL[9] - 1) / projL[5];
            const leftFov = (projL[8] - 1) / projL[0];
            const rightFov = (projR[8] + 1) / projR[0];
            const left = near * leftFov;
            const right = near * rightFov;
            // Calculate the new camera's position offset from the
            // left camera. xOffset should be roughly half `ipd`.
            const zOffset = ipd / (-leftFov + rightFov);
            const xOffset = zOffset * -leftFov;
            // TODO: Better way to apply this offset?
            cameraL.matrixWorld.decompose(camera.position, camera.quaternion, camera.scale);
            camera.translateX(xOffset);
            camera.translateZ(zOffset);
            camera.matrixWorld.compose(camera.position, camera.quaternion, camera.scale);
            camera.matrixWorldInverse.copy(camera.matrixWorld).invert();
            // Check if the projection uses an infinite far plane.
            if (projL[10] === -1) {
                // Use the projection matrix from the left eye.
                // The camera offset is sufficient to include the view volumes
                // of both eyes (assuming symmetric projections).
                camera.projectionMatrix.copy(cameraL.projectionMatrix);
                camera.projectionMatrixInverse.copy(cameraL.projectionMatrixInverse);
            } else {
                // Find the union of the frustum values of the cameras and scale
                // the values so that the near plane's position does not change in world space,
                // although must now be relative to the new union camera.
                const near2 = near + zOffset;
                const far2 = far + zOffset;
                const left2 = left - xOffset;
                const right2 = right + (ipd - xOffset);
                const top2 = topFov * far / far2 * near2;
                const bottom2 = bottomFov * far / far2 * near2;
                camera.projectionMatrix.makePerspective(left2, right2, top2, bottom2, near2, far2);
                camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert();
            }
        }
        function updateCamera(camera, parent) {
            if (parent === null) camera.matrixWorld.copy(camera.matrix);
            else camera.matrixWorld.multiplyMatrices(parent.matrixWorld, camera.matrix);
            camera.matrixWorldInverse.copy(camera.matrixWorld).invert();
        }
        this.updateCamera = function(camera) {
            if (session === null) return;
            let depthNear = camera.near;
            let depthFar = camera.far;
            if (depthSensing.texture !== null) {
                if (depthSensing.depthNear > 0) depthNear = depthSensing.depthNear;
                if (depthSensing.depthFar > 0) depthFar = depthSensing.depthFar;
            }
            cameraXR.near = cameraR.near = cameraL.near = depthNear;
            cameraXR.far = cameraR.far = cameraL.far = depthFar;
            if (_currentDepthNear !== cameraXR.near || _currentDepthFar !== cameraXR.far) {
                // Note that the new renderState won't apply until the next frame. See #18320
                session.updateRenderState({
                    depthNear: cameraXR.near,
                    depthFar: cameraXR.far
                });
                _currentDepthNear = cameraXR.near;
                _currentDepthFar = cameraXR.far;
            }
            cameraL.layers.mask = camera.layers.mask | 2;
            cameraR.layers.mask = camera.layers.mask | 4;
            cameraXR.layers.mask = cameraL.layers.mask | cameraR.layers.mask;
            const parent = camera.parent;
            const cameras = cameraXR.cameras;
            updateCamera(cameraXR, parent);
            for(let i = 0; i < cameras.length; i++)updateCamera(cameras[i], parent);
            // update projection matrix for proper view frustum culling
            if (cameras.length === 2) setProjectionFromUnion(cameraXR, cameraL, cameraR);
            else // assume single camera setup (AR)
            cameraXR.projectionMatrix.copy(cameraL.projectionMatrix);
            // update user camera and its children
            updateUserCamera(camera, cameraXR, parent);
        };
        function updateUserCamera(camera, cameraXR, parent) {
            if (parent === null) camera.matrix.copy(cameraXR.matrixWorld);
            else {
                camera.matrix.copy(parent.matrixWorld);
                camera.matrix.invert();
                camera.matrix.multiply(cameraXR.matrixWorld);
            }
            camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);
            camera.updateMatrixWorld(true);
            camera.projectionMatrix.copy(cameraXR.projectionMatrix);
            camera.projectionMatrixInverse.copy(cameraXR.projectionMatrixInverse);
            if (camera.isPerspectiveCamera) {
                camera.fov = (0, $d5b85d29c0b78636$export$914076c8150813e5) * 2 * Math.atan(1 / camera.projectionMatrix.elements[5]);
                camera.zoom = 1;
            }
        }
        this.getCamera = function() {
            return cameraXR;
        };
        this.getFoveation = function() {
            if (glProjLayer === null && glBaseLayer === null) return undefined;
            return foveation;
        };
        this.setFoveation = function(value) {
            // 0 = no foveation = full resolution
            // 1 = maximum foveation = the edges render at lower resolution
            foveation = value;
            if (glProjLayer !== null) glProjLayer.fixedFoveation = value;
            if (glBaseLayer !== null && glBaseLayer.fixedFoveation !== undefined) glBaseLayer.fixedFoveation = value;
        };
        this.hasDepthSensing = function() {
            return depthSensing.texture !== null;
        };
        this.getDepthSensingMesh = function() {
            return depthSensing.getMesh(cameraXR);
        };
        // Animation Loop
        let onAnimationFrameCallback = null;
        function onAnimationFrame(time, frame) {
            pose = frame.getViewerPose(customReferenceSpace || referenceSpace);
            xrFrame = frame;
            if (pose !== null) {
                const views = pose.views;
                if (glBaseLayer !== null) {
                    renderer.setRenderTargetFramebuffer(newRenderTarget, glBaseLayer.framebuffer);
                    renderer.setRenderTarget(newRenderTarget);
                }
                let cameraXRNeedsUpdate = false;
                // check if it's necessary to rebuild cameraXR's camera list
                if (views.length !== cameraXR.cameras.length) {
                    cameraXR.cameras.length = 0;
                    cameraXRNeedsUpdate = true;
                }
                for(let i = 0; i < views.length; i++){
                    const view = views[i];
                    let viewport = null;
                    if (glBaseLayer !== null) viewport = glBaseLayer.getViewport(view);
                    else {
                        const glSubImage = glBinding.getViewSubImage(glProjLayer, view);
                        viewport = glSubImage.viewport;
                        // For side-by-side projection, we only produce a single texture for both eyes.
                        if (i === 0) {
                            renderer.setRenderTargetTextures(newRenderTarget, glSubImage.colorTexture, glProjLayer.ignoreDepthValues ? undefined : glSubImage.depthStencilTexture);
                            renderer.setRenderTarget(newRenderTarget);
                        }
                    }
                    let camera = cameras[i];
                    if (camera === undefined) {
                        camera = new (0, $d5b85d29c0b78636$export$74e4ae24825f68d7)();
                        camera.layers.enable(i);
                        camera.viewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
                        cameras[i] = camera;
                    }
                    camera.matrix.fromArray(view.transform.matrix);
                    camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);
                    camera.projectionMatrix.fromArray(view.projectionMatrix);
                    camera.projectionMatrixInverse.copy(camera.projectionMatrix).invert();
                    camera.viewport.set(viewport.x, viewport.y, viewport.width, viewport.height);
                    if (i === 0) {
                        cameraXR.matrix.copy(camera.matrix);
                        cameraXR.matrix.decompose(cameraXR.position, cameraXR.quaternion, cameraXR.scale);
                    }
                    if (cameraXRNeedsUpdate === true) cameraXR.cameras.push(camera);
                }
                //
                const enabledFeatures = session.enabledFeatures;
                if (enabledFeatures && enabledFeatures.includes('depth-sensing')) {
                    const depthData = glBinding.getDepthInformation(views[0]);
                    if (depthData && depthData.isValid && depthData.texture) depthSensing.init(renderer, depthData, session.renderState);
                }
            }
            //
            for(let i = 0; i < controllers.length; i++){
                const inputSource = controllerInputSources[i];
                const controller = controllers[i];
                if (inputSource !== null && controller !== undefined) controller.update(inputSource, frame, customReferenceSpace || referenceSpace);
            }
            if (onAnimationFrameCallback) onAnimationFrameCallback(time, frame);
            if (frame.detectedPlanes) scope.dispatchEvent({
                type: 'planesdetected',
                data: frame
            });
            xrFrame = null;
        }
        const animation = new $3dd44ec8564e7230$var$WebGLAnimation();
        animation.setAnimationLoop(onAnimationFrame);
        this.setAnimationLoop = function(callback) {
            onAnimationFrameCallback = callback;
        };
        this.dispose = function() {};
    }
}
const $3dd44ec8564e7230$var$_e1 = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$d93cc409a0768c5f)();
const $3dd44ec8564e7230$var$_m1 = /*@__PURE__*/ new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
function $3dd44ec8564e7230$var$WebGLMaterials(renderer, properties) {
    function refreshTransformUniform(map, uniform) {
        if (map.matrixAutoUpdate === true) map.updateMatrix();
        uniform.value.copy(map.matrix);
    }
    function refreshFogUniforms(uniforms, fog) {
        fog.color.getRGB(uniforms.fogColor.value, (0, $d5b85d29c0b78636$export$a630742c640528c1)(renderer));
        if (fog.isFog) {
            uniforms.fogNear.value = fog.near;
            uniforms.fogFar.value = fog.far;
        } else if (fog.isFogExp2) uniforms.fogDensity.value = fog.density;
    }
    function refreshMaterialUniforms(uniforms, material, pixelRatio, height, transmissionRenderTarget) {
        if (material.isMeshBasicMaterial) refreshUniformsCommon(uniforms, material);
        else if (material.isMeshLambertMaterial) refreshUniformsCommon(uniforms, material);
        else if (material.isMeshToonMaterial) {
            refreshUniformsCommon(uniforms, material);
            refreshUniformsToon(uniforms, material);
        } else if (material.isMeshPhongMaterial) {
            refreshUniformsCommon(uniforms, material);
            refreshUniformsPhong(uniforms, material);
        } else if (material.isMeshStandardMaterial) {
            refreshUniformsCommon(uniforms, material);
            refreshUniformsStandard(uniforms, material);
            if (material.isMeshPhysicalMaterial) refreshUniformsPhysical(uniforms, material, transmissionRenderTarget);
        } else if (material.isMeshMatcapMaterial) {
            refreshUniformsCommon(uniforms, material);
            refreshUniformsMatcap(uniforms, material);
        } else if (material.isMeshDepthMaterial) refreshUniformsCommon(uniforms, material);
        else if (material.isMeshDistanceMaterial) {
            refreshUniformsCommon(uniforms, material);
            refreshUniformsDistance(uniforms, material);
        } else if (material.isMeshNormalMaterial) refreshUniformsCommon(uniforms, material);
        else if (material.isLineBasicMaterial) {
            refreshUniformsLine(uniforms, material);
            if (material.isLineDashedMaterial) refreshUniformsDash(uniforms, material);
        } else if (material.isPointsMaterial) refreshUniformsPoints(uniforms, material, pixelRatio, height);
        else if (material.isSpriteMaterial) refreshUniformsSprites(uniforms, material);
        else if (material.isShadowMaterial) {
            uniforms.color.value.copy(material.color);
            uniforms.opacity.value = material.opacity;
        } else if (material.isShaderMaterial) material.uniformsNeedUpdate = false; // #15581
    }
    function refreshUniformsCommon(uniforms, material) {
        uniforms.opacity.value = material.opacity;
        if (material.color) uniforms.diffuse.value.copy(material.color);
        if (material.emissive) uniforms.emissive.value.copy(material.emissive).multiplyScalar(material.emissiveIntensity);
        if (material.map) {
            uniforms.map.value = material.map;
            refreshTransformUniform(material.map, uniforms.mapTransform);
        }
        if (material.alphaMap) {
            uniforms.alphaMap.value = material.alphaMap;
            refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform);
        }
        if (material.bumpMap) {
            uniforms.bumpMap.value = material.bumpMap;
            refreshTransformUniform(material.bumpMap, uniforms.bumpMapTransform);
            uniforms.bumpScale.value = material.bumpScale;
            if (material.side === (0, $d5b85d29c0b78636$export$d9f0486e75b5ace)) uniforms.bumpScale.value *= -1;
        }
        if (material.normalMap) {
            uniforms.normalMap.value = material.normalMap;
            refreshTransformUniform(material.normalMap, uniforms.normalMapTransform);
            uniforms.normalScale.value.copy(material.normalScale);
            if (material.side === (0, $d5b85d29c0b78636$export$d9f0486e75b5ace)) uniforms.normalScale.value.negate();
        }
        if (material.displacementMap) {
            uniforms.displacementMap.value = material.displacementMap;
            refreshTransformUniform(material.displacementMap, uniforms.displacementMapTransform);
            uniforms.displacementScale.value = material.displacementScale;
            uniforms.displacementBias.value = material.displacementBias;
        }
        if (material.emissiveMap) {
            uniforms.emissiveMap.value = material.emissiveMap;
            refreshTransformUniform(material.emissiveMap, uniforms.emissiveMapTransform);
        }
        if (material.specularMap) {
            uniforms.specularMap.value = material.specularMap;
            refreshTransformUniform(material.specularMap, uniforms.specularMapTransform);
        }
        if (material.alphaTest > 0) uniforms.alphaTest.value = material.alphaTest;
        const materialProperties = properties.get(material);
        const envMap = materialProperties.envMap;
        const envMapRotation = materialProperties.envMapRotation;
        if (envMap) {
            uniforms.envMap.value = envMap;
            $3dd44ec8564e7230$var$_e1.copy(envMapRotation);
            // accommodate left-handed frame
            $3dd44ec8564e7230$var$_e1.x *= -1;
            $3dd44ec8564e7230$var$_e1.y *= -1;
            $3dd44ec8564e7230$var$_e1.z *= -1;
            if (envMap.isCubeTexture && envMap.isRenderTargetTexture === false) {
                // environment maps which are not cube render targets or PMREMs follow a different convention
                $3dd44ec8564e7230$var$_e1.y *= -1;
                $3dd44ec8564e7230$var$_e1.z *= -1;
            }
            uniforms.envMapRotation.value.setFromMatrix4($3dd44ec8564e7230$var$_m1.makeRotationFromEuler($3dd44ec8564e7230$var$_e1));
            uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap.isRenderTargetTexture === false ? -1 : 1;
            uniforms.reflectivity.value = material.reflectivity;
            uniforms.ior.value = material.ior;
            uniforms.refractionRatio.value = material.refractionRatio;
        }
        if (material.lightMap) {
            uniforms.lightMap.value = material.lightMap;
            uniforms.lightMapIntensity.value = material.lightMapIntensity;
            refreshTransformUniform(material.lightMap, uniforms.lightMapTransform);
        }
        if (material.aoMap) {
            uniforms.aoMap.value = material.aoMap;
            uniforms.aoMapIntensity.value = material.aoMapIntensity;
            refreshTransformUniform(material.aoMap, uniforms.aoMapTransform);
        }
    }
    function refreshUniformsLine(uniforms, material) {
        uniforms.diffuse.value.copy(material.color);
        uniforms.opacity.value = material.opacity;
        if (material.map) {
            uniforms.map.value = material.map;
            refreshTransformUniform(material.map, uniforms.mapTransform);
        }
    }
    function refreshUniformsDash(uniforms, material) {
        uniforms.dashSize.value = material.dashSize;
        uniforms.totalSize.value = material.dashSize + material.gapSize;
        uniforms.scale.value = material.scale;
    }
    function refreshUniformsPoints(uniforms, material, pixelRatio, height) {
        uniforms.diffuse.value.copy(material.color);
        uniforms.opacity.value = material.opacity;
        uniforms.size.value = material.size * pixelRatio;
        uniforms.scale.value = height * 0.5;
        if (material.map) {
            uniforms.map.value = material.map;
            refreshTransformUniform(material.map, uniforms.uvTransform);
        }
        if (material.alphaMap) {
            uniforms.alphaMap.value = material.alphaMap;
            refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform);
        }
        if (material.alphaTest > 0) uniforms.alphaTest.value = material.alphaTest;
    }
    function refreshUniformsSprites(uniforms, material) {
        uniforms.diffuse.value.copy(material.color);
        uniforms.opacity.value = material.opacity;
        uniforms.rotation.value = material.rotation;
        if (material.map) {
            uniforms.map.value = material.map;
            refreshTransformUniform(material.map, uniforms.mapTransform);
        }
        if (material.alphaMap) {
            uniforms.alphaMap.value = material.alphaMap;
            refreshTransformUniform(material.alphaMap, uniforms.alphaMapTransform);
        }
        if (material.alphaTest > 0) uniforms.alphaTest.value = material.alphaTest;
    }
    function refreshUniformsPhong(uniforms, material) {
        uniforms.specular.value.copy(material.specular);
        uniforms.shininess.value = Math.max(material.shininess, 1e-4); // to prevent pow( 0.0, 0.0 )
    }
    function refreshUniformsToon(uniforms, material) {
        if (material.gradientMap) uniforms.gradientMap.value = material.gradientMap;
    }
    function refreshUniformsStandard(uniforms, material) {
        uniforms.metalness.value = material.metalness;
        if (material.metalnessMap) {
            uniforms.metalnessMap.value = material.metalnessMap;
            refreshTransformUniform(material.metalnessMap, uniforms.metalnessMapTransform);
        }
        uniforms.roughness.value = material.roughness;
        if (material.roughnessMap) {
            uniforms.roughnessMap.value = material.roughnessMap;
            refreshTransformUniform(material.roughnessMap, uniforms.roughnessMapTransform);
        }
        if (material.envMap) //uniforms.envMap.value = material.envMap; // part of uniforms common
        uniforms.envMapIntensity.value = material.envMapIntensity;
    }
    function refreshUniformsPhysical(uniforms, material, transmissionRenderTarget) {
        uniforms.ior.value = material.ior; // also part of uniforms common
        if (material.sheen > 0) {
            uniforms.sheenColor.value.copy(material.sheenColor).multiplyScalar(material.sheen);
            uniforms.sheenRoughness.value = material.sheenRoughness;
            if (material.sheenColorMap) {
                uniforms.sheenColorMap.value = material.sheenColorMap;
                refreshTransformUniform(material.sheenColorMap, uniforms.sheenColorMapTransform);
            }
            if (material.sheenRoughnessMap) {
                uniforms.sheenRoughnessMap.value = material.sheenRoughnessMap;
                refreshTransformUniform(material.sheenRoughnessMap, uniforms.sheenRoughnessMapTransform);
            }
        }
        if (material.clearcoat > 0) {
            uniforms.clearcoat.value = material.clearcoat;
            uniforms.clearcoatRoughness.value = material.clearcoatRoughness;
            if (material.clearcoatMap) {
                uniforms.clearcoatMap.value = material.clearcoatMap;
                refreshTransformUniform(material.clearcoatMap, uniforms.clearcoatMapTransform);
            }
            if (material.clearcoatRoughnessMap) {
                uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap;
                refreshTransformUniform(material.clearcoatRoughnessMap, uniforms.clearcoatRoughnessMapTransform);
            }
            if (material.clearcoatNormalMap) {
                uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap;
                refreshTransformUniform(material.clearcoatNormalMap, uniforms.clearcoatNormalMapTransform);
                uniforms.clearcoatNormalScale.value.copy(material.clearcoatNormalScale);
                if (material.side === (0, $d5b85d29c0b78636$export$d9f0486e75b5ace)) uniforms.clearcoatNormalScale.value.negate();
            }
        }
        if (material.dispersion > 0) uniforms.dispersion.value = material.dispersion;
        if (material.iridescence > 0) {
            uniforms.iridescence.value = material.iridescence;
            uniforms.iridescenceIOR.value = material.iridescenceIOR;
            uniforms.iridescenceThicknessMinimum.value = material.iridescenceThicknessRange[0];
            uniforms.iridescenceThicknessMaximum.value = material.iridescenceThicknessRange[1];
            if (material.iridescenceMap) {
                uniforms.iridescenceMap.value = material.iridescenceMap;
                refreshTransformUniform(material.iridescenceMap, uniforms.iridescenceMapTransform);
            }
            if (material.iridescenceThicknessMap) {
                uniforms.iridescenceThicknessMap.value = material.iridescenceThicknessMap;
                refreshTransformUniform(material.iridescenceThicknessMap, uniforms.iridescenceThicknessMapTransform);
            }
        }
        if (material.transmission > 0) {
            uniforms.transmission.value = material.transmission;
            uniforms.transmissionSamplerMap.value = transmissionRenderTarget.texture;
            uniforms.transmissionSamplerSize.value.set(transmissionRenderTarget.width, transmissionRenderTarget.height);
            if (material.transmissionMap) {
                uniforms.transmissionMap.value = material.transmissionMap;
                refreshTransformUniform(material.transmissionMap, uniforms.transmissionMapTransform);
            }
            uniforms.thickness.value = material.thickness;
            if (material.thicknessMap) {
                uniforms.thicknessMap.value = material.thicknessMap;
                refreshTransformUniform(material.thicknessMap, uniforms.thicknessMapTransform);
            }
            uniforms.attenuationDistance.value = material.attenuationDistance;
            uniforms.attenuationColor.value.copy(material.attenuationColor);
        }
        if (material.anisotropy > 0) {
            uniforms.anisotropyVector.value.set(material.anisotropy * Math.cos(material.anisotropyRotation), material.anisotropy * Math.sin(material.anisotropyRotation));
            if (material.anisotropyMap) {
                uniforms.anisotropyMap.value = material.anisotropyMap;
                refreshTransformUniform(material.anisotropyMap, uniforms.anisotropyMapTransform);
            }
        }
        uniforms.specularIntensity.value = material.specularIntensity;
        uniforms.specularColor.value.copy(material.specularColor);
        if (material.specularColorMap) {
            uniforms.specularColorMap.value = material.specularColorMap;
            refreshTransformUniform(material.specularColorMap, uniforms.specularColorMapTransform);
        }
        if (material.specularIntensityMap) {
            uniforms.specularIntensityMap.value = material.specularIntensityMap;
            refreshTransformUniform(material.specularIntensityMap, uniforms.specularIntensityMapTransform);
        }
    }
    function refreshUniformsMatcap(uniforms, material) {
        if (material.matcap) uniforms.matcap.value = material.matcap;
    }
    function refreshUniformsDistance(uniforms, material) {
        const light = properties.get(material).light;
        uniforms.referencePosition.value.setFromMatrixPosition(light.matrixWorld);
        uniforms.nearDistance.value = light.shadow.camera.near;
        uniforms.farDistance.value = light.shadow.camera.far;
    }
    return {
        refreshFogUniforms: refreshFogUniforms,
        refreshMaterialUniforms: refreshMaterialUniforms
    };
}
function $3dd44ec8564e7230$var$WebGLUniformsGroups(gl, info, capabilities, state) {
    let buffers = {};
    let updateList = {};
    let allocatedBindingPoints = [];
    const maxBindingPoints = gl.getParameter(gl.MAX_UNIFORM_BUFFER_BINDINGS); // binding points are global whereas block indices are per shader program
    function bind(uniformsGroup, program) {
        const webglProgram = program.program;
        state.uniformBlockBinding(uniformsGroup, webglProgram);
    }
    function update(uniformsGroup, program) {
        let buffer = buffers[uniformsGroup.id];
        if (buffer === undefined) {
            prepareUniformsGroup(uniformsGroup);
            buffer = createBuffer(uniformsGroup);
            buffers[uniformsGroup.id] = buffer;
            uniformsGroup.addEventListener('dispose', onUniformsGroupsDispose);
        }
        // ensure to update the binding points/block indices mapping for this program
        const webglProgram = program.program;
        state.updateUBOMapping(uniformsGroup, webglProgram);
        // update UBO once per frame
        const frame = info.render.frame;
        if (updateList[uniformsGroup.id] !== frame) {
            updateBufferData(uniformsGroup);
            updateList[uniformsGroup.id] = frame;
        }
    }
    function createBuffer(uniformsGroup) {
        // the setup of an UBO is independent of a particular shader program but global
        const bindingPointIndex = allocateBindingPointIndex();
        uniformsGroup.__bindingPointIndex = bindingPointIndex;
        const buffer = gl.createBuffer();
        const size = uniformsGroup.__size;
        const usage = uniformsGroup.usage;
        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
        gl.bufferData(gl.UNIFORM_BUFFER, size, usage);
        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
        gl.bindBufferBase(gl.UNIFORM_BUFFER, bindingPointIndex, buffer);
        return buffer;
    }
    function allocateBindingPointIndex() {
        for(let i = 0; i < maxBindingPoints; i++)if (allocatedBindingPoints.indexOf(i) === -1) {
            allocatedBindingPoints.push(i);
            return i;
        }
        console.error('THREE.WebGLRenderer: Maximum number of simultaneously usable uniforms groups reached.');
        return 0;
    }
    function updateBufferData(uniformsGroup) {
        const buffer = buffers[uniformsGroup.id];
        const uniforms = uniformsGroup.uniforms;
        const cache = uniformsGroup.__cache;
        gl.bindBuffer(gl.UNIFORM_BUFFER, buffer);
        for(let i = 0, il = uniforms.length; i < il; i++){
            const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [
                uniforms[i]
            ];
            for(let j = 0, jl = uniformArray.length; j < jl; j++){
                const uniform = uniformArray[j];
                if (hasUniformChanged(uniform, i, j, cache) === true) {
                    const offset = uniform.__offset;
                    const values = Array.isArray(uniform.value) ? uniform.value : [
                        uniform.value
                    ];
                    let arrayOffset = 0;
                    for(let k = 0; k < values.length; k++){
                        const value = values[k];
                        const info = getUniformSize(value);
                        // TODO add integer and struct support
                        if (typeof value === 'number' || typeof value === 'boolean') {
                            uniform.__data[0] = value;
                            gl.bufferSubData(gl.UNIFORM_BUFFER, offset + arrayOffset, uniform.__data);
                        } else if (value.isMatrix3) {
                            // manually converting 3x3 to 3x4
                            uniform.__data[0] = value.elements[0];
                            uniform.__data[1] = value.elements[1];
                            uniform.__data[2] = value.elements[2];
                            uniform.__data[3] = 0;
                            uniform.__data[4] = value.elements[3];
                            uniform.__data[5] = value.elements[4];
                            uniform.__data[6] = value.elements[5];
                            uniform.__data[7] = 0;
                            uniform.__data[8] = value.elements[6];
                            uniform.__data[9] = value.elements[7];
                            uniform.__data[10] = value.elements[8];
                            uniform.__data[11] = 0;
                        } else {
                            value.toArray(uniform.__data, arrayOffset);
                            arrayOffset += info.storage / Float32Array.BYTES_PER_ELEMENT;
                        }
                    }
                    gl.bufferSubData(gl.UNIFORM_BUFFER, offset, uniform.__data);
                }
            }
        }
        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
    }
    function hasUniformChanged(uniform, index, indexArray, cache) {
        const value = uniform.value;
        const indexString = index + '_' + indexArray;
        if (cache[indexString] === undefined) {
            // cache entry does not exist so far
            if (typeof value === 'number' || typeof value === 'boolean') cache[indexString] = value;
            else cache[indexString] = value.clone();
            return true;
        } else {
            const cachedObject = cache[indexString];
            // compare current value with cached entry
            if (typeof value === 'number' || typeof value === 'boolean') {
                if (cachedObject !== value) {
                    cache[indexString] = value;
                    return true;
                }
            } else if (cachedObject.equals(value) === false) {
                cachedObject.copy(value);
                return true;
            }
        }
        return false;
    }
    function prepareUniformsGroup(uniformsGroup) {
        // determine total buffer size according to the STD140 layout
        // Hint: STD140 is the only supported layout in WebGL 2
        const uniforms = uniformsGroup.uniforms;
        let offset = 0; // global buffer offset in bytes
        const chunkSize = 16; // size of a chunk in bytes
        for(let i = 0, l = uniforms.length; i < l; i++){
            const uniformArray = Array.isArray(uniforms[i]) ? uniforms[i] : [
                uniforms[i]
            ];
            for(let j = 0, jl = uniformArray.length; j < jl; j++){
                const uniform = uniformArray[j];
                const values = Array.isArray(uniform.value) ? uniform.value : [
                    uniform.value
                ];
                for(let k = 0, kl = values.length; k < kl; k++){
                    const value = values[k];
                    const info = getUniformSize(value);
                    const chunkOffset = offset % chunkSize; // offset in the current chunk
                    const chunkPadding = chunkOffset % info.boundary; // required padding to match boundary
                    const chunkStart = chunkOffset + chunkPadding; // the start position in the current chunk for the data
                    offset += chunkPadding;
                    // Check for chunk overflow
                    if (chunkStart !== 0 && chunkSize - chunkStart < info.storage) // Add padding and adjust offset
                    offset += chunkSize - chunkStart;
                    // the following two properties will be used for partial buffer updates
                    uniform.__data = new Float32Array(info.storage / Float32Array.BYTES_PER_ELEMENT);
                    uniform.__offset = offset;
                    // Update the global offset
                    offset += info.storage;
                }
            }
        }
        // ensure correct final padding
        const chunkOffset = offset % chunkSize;
        if (chunkOffset > 0) offset += chunkSize - chunkOffset;
        //
        uniformsGroup.__size = offset;
        uniformsGroup.__cache = {};
        return this;
    }
    function getUniformSize(value) {
        const info = {
            boundary: 0,
            storage: 0 // bytes
        };
        // determine sizes according to STD140
        if (typeof value === 'number' || typeof value === 'boolean') {
            // float/int/bool
            info.boundary = 4;
            info.storage = 4;
        } else if (value.isVector2) {
            // vec2
            info.boundary = 8;
            info.storage = 8;
        } else if (value.isVector3 || value.isColor) {
            // vec3
            info.boundary = 16;
            info.storage = 12; // evil: vec3 must start on a 16-byte boundary but it only consumes 12 bytes
        } else if (value.isVector4) {
            // vec4
            info.boundary = 16;
            info.storage = 16;
        } else if (value.isMatrix3) {
            // mat3 (in STD140 a 3x3 matrix is represented as 3x4)
            info.boundary = 48;
            info.storage = 48;
        } else if (value.isMatrix4) {
            // mat4
            info.boundary = 64;
            info.storage = 64;
        } else if (value.isTexture) console.warn('THREE.WebGLRenderer: Texture samplers can not be part of an uniforms group.');
        else console.warn('THREE.WebGLRenderer: Unsupported uniform value type.', value);
        return info;
    }
    function onUniformsGroupsDispose(event) {
        const uniformsGroup = event.target;
        uniformsGroup.removeEventListener('dispose', onUniformsGroupsDispose);
        const index = allocatedBindingPoints.indexOf(uniformsGroup.__bindingPointIndex);
        allocatedBindingPoints.splice(index, 1);
        gl.deleteBuffer(buffers[uniformsGroup.id]);
        delete buffers[uniformsGroup.id];
        delete updateList[uniformsGroup.id];
    }
    function dispose() {
        for(const id in buffers)gl.deleteBuffer(buffers[id]);
        allocatedBindingPoints = [];
        buffers = {};
        updateList = {};
    }
    return {
        bind: bind,
        update: update,
        dispose: dispose
    };
}
class $3dd44ec8564e7230$export$f6cc00ef28d7cf97 {
    constructor(parameters = {}){
        const { canvas: canvas = (0, $d5b85d29c0b78636$export$1033a2df66368859)(), context: context = null, depth: depth = true, stencil: stencil = false, alpha: alpha = false, antialias: antialias = false, premultipliedAlpha: premultipliedAlpha = true, preserveDrawingBuffer: preserveDrawingBuffer = false, powerPreference: powerPreference = 'default', failIfMajorPerformanceCaveat: failIfMajorPerformanceCaveat = false, reverseDepthBuffer: reverseDepthBuffer = false } = parameters;
        this.isWebGLRenderer = true;
        let _alpha;
        if (context !== null) {
            if (typeof WebGLRenderingContext !== 'undefined' && context instanceof WebGLRenderingContext) throw new Error('THREE.WebGLRenderer: WebGL 1 is not supported since r163.');
            _alpha = context.getContextAttributes().alpha;
        } else _alpha = alpha;
        const uintClearColor = new Uint32Array(4);
        const intClearColor = new Int32Array(4);
        let currentRenderList = null;
        let currentRenderState = null;
        // render() can be called from within a callback triggered by another render.
        // We track this so that the nested render call gets its list and state isolated from the parent render call.
        const renderListStack = [];
        const renderStateStack = [];
        // public properties
        this.domElement = canvas;
        // Debug configuration container
        this.debug = {
            /**
			 * Enables error checking and reporting when shader programs are being compiled
			 * @type {boolean}
			 */ checkShaderErrors: true,
            /**
			 * Callback for custom error reporting.
			 * @type {?Function}
			 */ onShaderError: null
        };
        // clearing
        this.autoClear = true;
        this.autoClearColor = true;
        this.autoClearDepth = true;
        this.autoClearStencil = true;
        // scene graph
        this.sortObjects = true;
        // user-defined clipping
        this.clippingPlanes = [];
        this.localClippingEnabled = false;
        // physically based shading
        this._outputColorSpace = (0, $d5b85d29c0b78636$export$561f394b24edfcaa);
        // tone mapping
        this.toneMapping = (0, $d5b85d29c0b78636$export$9fcb6b4294603b2);
        this.toneMappingExposure = 1.0;
        // internal properties
        const _this = this;
        let _isContextLost = false;
        // internal state cache
        let _currentActiveCubeFace = 0;
        let _currentActiveMipmapLevel = 0;
        let _currentRenderTarget = null;
        let _currentMaterialId = -1;
        let _currentCamera = null;
        const _currentViewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
        const _currentScissor = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
        let _currentScissorTest = null;
        const _currentClearColor = new (0, $d5b85d29c0b78636$export$892596cec99bc70e)(0x000000);
        let _currentClearAlpha = 0;
        //
        let _width = canvas.width;
        let _height = canvas.height;
        let _pixelRatio = 1;
        let _opaqueSort = null;
        let _transparentSort = null;
        const _viewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)(0, 0, _width, _height);
        const _scissor = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)(0, 0, _width, _height);
        let _scissorTest = false;
        // frustum
        const _frustum = new (0, $d5b85d29c0b78636$export$35efe6f4c85463d2)();
        // clipping
        let _clippingEnabled = false;
        let _localClippingEnabled = false;
        // transmission render target scale
        this.transmissionResolutionScale = 1.0;
        // camera matrices cache
        const _currentProjectionMatrix = new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
        const _projScreenMatrix = new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
        const _vector3 = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        const _vector4 = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
        const _emptyScene = {
            background: null,
            fog: null,
            environment: null,
            overrideMaterial: null,
            isScene: true
        };
        let _renderBackground = false;
        function getTargetPixelRatio() {
            return _currentRenderTarget === null ? _pixelRatio : 1;
        }
        // initialize
        let _gl = context;
        function getContext(contextName, contextAttributes) {
            return canvas.getContext(contextName, contextAttributes);
        }
        try {
            const contextAttributes = {
                alpha: true,
                depth: depth,
                stencil: stencil,
                antialias: antialias,
                premultipliedAlpha: premultipliedAlpha,
                preserveDrawingBuffer: preserveDrawingBuffer,
                powerPreference: powerPreference,
                failIfMajorPerformanceCaveat: failIfMajorPerformanceCaveat
            };
            // OffscreenCanvas does not have setAttribute, see #22811
            if ('setAttribute' in canvas) canvas.setAttribute('data-engine', `three.js r${(0, $d5b85d29c0b78636$export$3545e07a80636437)}`);
            // event listeners must be registered before WebGL context is created, see #12753
            canvas.addEventListener('webglcontextlost', onContextLost, false);
            canvas.addEventListener('webglcontextrestored', onContextRestore, false);
            canvas.addEventListener('webglcontextcreationerror', onContextCreationError, false);
            if (_gl === null) {
                const contextName = 'webgl2';
                _gl = getContext(contextName, contextAttributes);
                if (_gl === null) {
                    if (getContext(contextName)) throw new Error('Error creating WebGL context with your selected attributes.');
                    else throw new Error('Error creating WebGL context.');
                }
            }
        } catch (error) {
            console.error('THREE.WebGLRenderer: ' + error.message);
            throw error;
        }
        let extensions, capabilities, state, info;
        let properties, textures, cubemaps, cubeuvmaps, attributes, geometries, objects;
        let programCache, materials, renderLists, renderStates, clipping, shadowMap;
        let background, morphtargets, bufferRenderer, indexedBufferRenderer;
        let utils, bindingStates, uniformsGroups;
        function initGLContext() {
            extensions = new $3dd44ec8564e7230$var$WebGLExtensions(_gl);
            extensions.init();
            utils = new $3dd44ec8564e7230$export$ddaebcad857649a8(_gl, extensions);
            capabilities = new $3dd44ec8564e7230$var$WebGLCapabilities(_gl, extensions, parameters, utils);
            state = new $3dd44ec8564e7230$var$WebGLState(_gl, extensions);
            if (capabilities.reverseDepthBuffer && reverseDepthBuffer) state.buffers.depth.setReversed(true);
            info = new $3dd44ec8564e7230$var$WebGLInfo(_gl);
            properties = new $3dd44ec8564e7230$var$WebGLProperties();
            textures = new $3dd44ec8564e7230$var$WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info);
            cubemaps = new $3dd44ec8564e7230$var$WebGLCubeMaps(_this);
            cubeuvmaps = new $3dd44ec8564e7230$var$WebGLCubeUVMaps(_this);
            attributes = new $3dd44ec8564e7230$var$WebGLAttributes(_gl);
            bindingStates = new $3dd44ec8564e7230$var$WebGLBindingStates(_gl, attributes);
            geometries = new $3dd44ec8564e7230$var$WebGLGeometries(_gl, attributes, info, bindingStates);
            objects = new $3dd44ec8564e7230$var$WebGLObjects(_gl, geometries, attributes, info);
            morphtargets = new $3dd44ec8564e7230$var$WebGLMorphtargets(_gl, capabilities, textures);
            clipping = new $3dd44ec8564e7230$var$WebGLClipping(properties);
            programCache = new $3dd44ec8564e7230$var$WebGLPrograms(_this, cubemaps, cubeuvmaps, extensions, capabilities, bindingStates, clipping);
            materials = new $3dd44ec8564e7230$var$WebGLMaterials(_this, properties);
            renderLists = new $3dd44ec8564e7230$var$WebGLRenderLists();
            renderStates = new $3dd44ec8564e7230$var$WebGLRenderStates(extensions);
            background = new $3dd44ec8564e7230$var$WebGLBackground(_this, cubemaps, cubeuvmaps, state, objects, _alpha, premultipliedAlpha);
            shadowMap = new $3dd44ec8564e7230$var$WebGLShadowMap(_this, objects, capabilities);
            uniformsGroups = new $3dd44ec8564e7230$var$WebGLUniformsGroups(_gl, info, capabilities, state);
            bufferRenderer = new $3dd44ec8564e7230$var$WebGLBufferRenderer(_gl, extensions, info);
            indexedBufferRenderer = new $3dd44ec8564e7230$var$WebGLIndexedBufferRenderer(_gl, extensions, info);
            info.programs = programCache.programs;
            _this.capabilities = capabilities;
            _this.extensions = extensions;
            _this.properties = properties;
            _this.renderLists = renderLists;
            _this.shadowMap = shadowMap;
            _this.state = state;
            _this.info = info;
        }
        initGLContext();
        // xr
        const xr = new $3dd44ec8564e7230$var$WebXRManager(_this, _gl);
        this.xr = xr;
        // API
        this.getContext = function() {
            return _gl;
        };
        this.getContextAttributes = function() {
            return _gl.getContextAttributes();
        };
        this.forceContextLoss = function() {
            const extension = extensions.get('WEBGL_lose_context');
            if (extension) extension.loseContext();
        };
        this.forceContextRestore = function() {
            const extension = extensions.get('WEBGL_lose_context');
            if (extension) extension.restoreContext();
        };
        this.getPixelRatio = function() {
            return _pixelRatio;
        };
        this.setPixelRatio = function(value) {
            if (value === undefined) return;
            _pixelRatio = value;
            this.setSize(_width, _height, false);
        };
        this.getSize = function(target) {
            return target.set(_width, _height);
        };
        this.setSize = function(width, height, updateStyle = true) {
            if (xr.isPresenting) {
                console.warn('THREE.WebGLRenderer: Can\'t change size while VR device is presenting.');
                return;
            }
            _width = width;
            _height = height;
            canvas.width = Math.floor(width * _pixelRatio);
            canvas.height = Math.floor(height * _pixelRatio);
            if (updateStyle === true) {
                canvas.style.width = width + 'px';
                canvas.style.height = height + 'px';
            }
            this.setViewport(0, 0, width, height);
        };
        this.getDrawingBufferSize = function(target) {
            return target.set(_width * _pixelRatio, _height * _pixelRatio).floor();
        };
        this.setDrawingBufferSize = function(width, height, pixelRatio) {
            _width = width;
            _height = height;
            _pixelRatio = pixelRatio;
            canvas.width = Math.floor(width * pixelRatio);
            canvas.height = Math.floor(height * pixelRatio);
            this.setViewport(0, 0, width, height);
        };
        this.getCurrentViewport = function(target) {
            return target.copy(_currentViewport);
        };
        this.getViewport = function(target) {
            return target.copy(_viewport);
        };
        this.setViewport = function(x, y, width, height) {
            if (x.isVector4) _viewport.set(x.x, x.y, x.z, x.w);
            else _viewport.set(x, y, width, height);
            state.viewport(_currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).round());
        };
        this.getScissor = function(target) {
            return target.copy(_scissor);
        };
        this.setScissor = function(x, y, width, height) {
            if (x.isVector4) _scissor.set(x.x, x.y, x.z, x.w);
            else _scissor.set(x, y, width, height);
            state.scissor(_currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).round());
        };
        this.getScissorTest = function() {
            return _scissorTest;
        };
        this.setScissorTest = function(boolean) {
            state.setScissorTest(_scissorTest = boolean);
        };
        this.setOpaqueSort = function(method) {
            _opaqueSort = method;
        };
        this.setTransparentSort = function(method) {
            _transparentSort = method;
        };
        // Clearing
        this.getClearColor = function(target) {
            return target.copy(background.getClearColor());
        };
        this.setClearColor = function() {
            background.setClearColor.apply(background, arguments);
        };
        this.getClearAlpha = function() {
            return background.getClearAlpha();
        };
        this.setClearAlpha = function() {
            background.setClearAlpha.apply(background, arguments);
        };
        this.clear = function(color = true, depth = true, stencil = true) {
            let bits = 0;
            if (color) {
                // check if we're trying to clear an integer target
                let isIntegerFormat = false;
                if (_currentRenderTarget !== null) {
                    const targetFormat = _currentRenderTarget.texture.format;
                    isIntegerFormat = targetFormat === (0, $d5b85d29c0b78636$export$c200e7d26f592f21) || targetFormat === (0, $d5b85d29c0b78636$export$1ba1c45f9f77d4d7) || targetFormat === (0, $d5b85d29c0b78636$export$aa92e870a709d190);
                }
                // use the appropriate clear functions to clear the target if it's a signed
                // or unsigned integer target
                if (isIntegerFormat) {
                    const targetType = _currentRenderTarget.texture.type;
                    const isUnsignedType = targetType === (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10) || targetType === (0, $d5b85d29c0b78636$export$c3c7fc4518ebba96) || targetType === (0, $d5b85d29c0b78636$export$c63dc51868b06a9d) || targetType === (0, $d5b85d29c0b78636$export$6c8ea339bfab1301) || targetType === (0, $d5b85d29c0b78636$export$b3969b01faf587f2) || targetType === (0, $d5b85d29c0b78636$export$18886f8ae33e90de);
                    const clearColor = background.getClearColor();
                    const a = background.getClearAlpha();
                    const r = clearColor.r;
                    const g = clearColor.g;
                    const b = clearColor.b;
                    if (isUnsignedType) {
                        uintClearColor[0] = r;
                        uintClearColor[1] = g;
                        uintClearColor[2] = b;
                        uintClearColor[3] = a;
                        _gl.clearBufferuiv(_gl.COLOR, 0, uintClearColor);
                    } else {
                        intClearColor[0] = r;
                        intClearColor[1] = g;
                        intClearColor[2] = b;
                        intClearColor[3] = a;
                        _gl.clearBufferiv(_gl.COLOR, 0, intClearColor);
                    }
                } else bits |= _gl.COLOR_BUFFER_BIT;
            }
            if (depth) bits |= _gl.DEPTH_BUFFER_BIT;
            if (stencil) {
                bits |= _gl.STENCIL_BUFFER_BIT;
                this.state.buffers.stencil.setMask(0xffffffff);
            }
            _gl.clear(bits);
        };
        this.clearColor = function() {
            this.clear(true, false, false);
        };
        this.clearDepth = function() {
            this.clear(false, true, false);
        };
        this.clearStencil = function() {
            this.clear(false, false, true);
        };
        //
        this.dispose = function() {
            canvas.removeEventListener('webglcontextlost', onContextLost, false);
            canvas.removeEventListener('webglcontextrestored', onContextRestore, false);
            canvas.removeEventListener('webglcontextcreationerror', onContextCreationError, false);
            background.dispose();
            renderLists.dispose();
            renderStates.dispose();
            properties.dispose();
            cubemaps.dispose();
            cubeuvmaps.dispose();
            objects.dispose();
            bindingStates.dispose();
            uniformsGroups.dispose();
            programCache.dispose();
            xr.dispose();
            xr.removeEventListener('sessionstart', onXRSessionStart);
            xr.removeEventListener('sessionend', onXRSessionEnd);
            animation.stop();
        };
        // Events
        function onContextLost(event) {
            event.preventDefault();
            console.log('THREE.WebGLRenderer: Context Lost.');
            _isContextLost = true;
        }
        function onContextRestore() {
            console.log('THREE.WebGLRenderer: Context Restored.');
            _isContextLost = false;
            const infoAutoReset = info.autoReset;
            const shadowMapEnabled = shadowMap.enabled;
            const shadowMapAutoUpdate = shadowMap.autoUpdate;
            const shadowMapNeedsUpdate = shadowMap.needsUpdate;
            const shadowMapType = shadowMap.type;
            initGLContext();
            info.autoReset = infoAutoReset;
            shadowMap.enabled = shadowMapEnabled;
            shadowMap.autoUpdate = shadowMapAutoUpdate;
            shadowMap.needsUpdate = shadowMapNeedsUpdate;
            shadowMap.type = shadowMapType;
        }
        function onContextCreationError(event) {
            console.error('THREE.WebGLRenderer: A WebGL context could not be created. Reason: ', event.statusMessage);
        }
        function onMaterialDispose(event) {
            const material = event.target;
            material.removeEventListener('dispose', onMaterialDispose);
            deallocateMaterial(material);
        }
        // Buffer deallocation
        function deallocateMaterial(material) {
            releaseMaterialProgramReferences(material);
            properties.remove(material);
        }
        function releaseMaterialProgramReferences(material) {
            const programs = properties.get(material).programs;
            if (programs !== undefined) {
                programs.forEach(function(program) {
                    programCache.releaseProgram(program);
                });
                if (material.isShaderMaterial) programCache.releaseShaderCache(material);
            }
        }
        // Buffer rendering
        this.renderBufferDirect = function(camera, scene, geometry, material, object, group) {
            if (scene === null) scene = _emptyScene; // renderBufferDirect second parameter used to be fog (could be null)
            const frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0;
            const program = setProgram(camera, scene, geometry, material, object);
            state.setMaterial(material, frontFaceCW);
            //
            let index = geometry.index;
            let rangeFactor = 1;
            if (material.wireframe === true) {
                index = geometries.getWireframeAttribute(geometry);
                if (index === undefined) return;
                rangeFactor = 2;
            }
            //
            const drawRange = geometry.drawRange;
            const position = geometry.attributes.position;
            let drawStart = drawRange.start * rangeFactor;
            let drawEnd = (drawRange.start + drawRange.count) * rangeFactor;
            if (group !== null) {
                drawStart = Math.max(drawStart, group.start * rangeFactor);
                drawEnd = Math.min(drawEnd, (group.start + group.count) * rangeFactor);
            }
            if (index !== null) {
                drawStart = Math.max(drawStart, 0);
                drawEnd = Math.min(drawEnd, index.count);
            } else if (position !== undefined && position !== null) {
                drawStart = Math.max(drawStart, 0);
                drawEnd = Math.min(drawEnd, position.count);
            }
            const drawCount = drawEnd - drawStart;
            if (drawCount < 0 || drawCount === Infinity) return;
            //
            bindingStates.setup(object, material, program, geometry, index);
            let attribute;
            let renderer = bufferRenderer;
            if (index !== null) {
                attribute = attributes.get(index);
                renderer = indexedBufferRenderer;
                renderer.setIndex(attribute);
            }
            //
            if (object.isMesh) {
                if (material.wireframe === true) {
                    state.setLineWidth(material.wireframeLinewidth * getTargetPixelRatio());
                    renderer.setMode(_gl.LINES);
                } else renderer.setMode(_gl.TRIANGLES);
            } else if (object.isLine) {
                let lineWidth = material.linewidth;
                if (lineWidth === undefined) lineWidth = 1; // Not using Line*Material
                state.setLineWidth(lineWidth * getTargetPixelRatio());
                if (object.isLineSegments) renderer.setMode(_gl.LINES);
                else if (object.isLineLoop) renderer.setMode(_gl.LINE_LOOP);
                else renderer.setMode(_gl.LINE_STRIP);
            } else if (object.isPoints) renderer.setMode(_gl.POINTS);
            else if (object.isSprite) renderer.setMode(_gl.TRIANGLES);
            if (object.isBatchedMesh) {
                if (object._multiDrawInstances !== null) renderer.renderMultiDrawInstances(object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount, object._multiDrawInstances);
                else if (!extensions.get('WEBGL_multi_draw')) {
                    const starts = object._multiDrawStarts;
                    const counts = object._multiDrawCounts;
                    const drawCount = object._multiDrawCount;
                    const bytesPerElement = index ? attributes.get(index).bytesPerElement : 1;
                    const uniforms = properties.get(material).currentProgram.getUniforms();
                    for(let i = 0; i < drawCount; i++){
                        uniforms.setValue(_gl, '_gl_DrawID', i);
                        renderer.render(starts[i] / bytesPerElement, counts[i]);
                    }
                } else renderer.renderMultiDraw(object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount);
            } else if (object.isInstancedMesh) renderer.renderInstances(drawStart, drawCount, object.count);
            else if (geometry.isInstancedBufferGeometry) {
                const maxInstanceCount = geometry._maxInstanceCount !== undefined ? geometry._maxInstanceCount : Infinity;
                const instanceCount = Math.min(geometry.instanceCount, maxInstanceCount);
                renderer.renderInstances(drawStart, drawCount, instanceCount);
            } else renderer.render(drawStart, drawCount);
        };
        // Compile
        function prepareMaterial(material, scene, object) {
            if (material.transparent === true && material.side === (0, $d5b85d29c0b78636$export$3b296b6f144d5b03) && material.forceSinglePass === false) {
                material.side = (0, $d5b85d29c0b78636$export$d9f0486e75b5ace);
                material.needsUpdate = true;
                getProgram(material, scene, object);
                material.side = (0, $d5b85d29c0b78636$export$2ede184fc2998901);
                material.needsUpdate = true;
                getProgram(material, scene, object);
                material.side = (0, $d5b85d29c0b78636$export$3b296b6f144d5b03);
            } else getProgram(material, scene, object);
        }
        this.compile = function(scene, camera, targetScene = null) {
            if (targetScene === null) targetScene = scene;
            currentRenderState = renderStates.get(targetScene);
            currentRenderState.init(camera);
            renderStateStack.push(currentRenderState);
            // gather lights from both the target scene and the new object that will be added to the scene.
            targetScene.traverseVisible(function(object) {
                if (object.isLight && object.layers.test(camera.layers)) {
                    currentRenderState.pushLight(object);
                    if (object.castShadow) currentRenderState.pushShadow(object);
                }
            });
            if (scene !== targetScene) scene.traverseVisible(function(object) {
                if (object.isLight && object.layers.test(camera.layers)) {
                    currentRenderState.pushLight(object);
                    if (object.castShadow) currentRenderState.pushShadow(object);
                }
            });
            currentRenderState.setupLights();
            // Only initialize materials in the new scene, not the targetScene.
            const materials = new Set();
            scene.traverse(function(object) {
                if (!(object.isMesh || object.isPoints || object.isLine || object.isSprite)) return;
                const material = object.material;
                if (material) {
                    if (Array.isArray(material)) for(let i = 0; i < material.length; i++){
                        const material2 = material[i];
                        prepareMaterial(material2, targetScene, object);
                        materials.add(material2);
                    }
                    else {
                        prepareMaterial(material, targetScene, object);
                        materials.add(material);
                    }
                }
            });
            renderStateStack.pop();
            currentRenderState = null;
            return materials;
        };
        // compileAsync
        this.compileAsync = function(scene, camera, targetScene = null) {
            const materials = this.compile(scene, camera, targetScene);
            // Wait for all the materials in the new object to indicate that they're
            // ready to be used before resolving the promise.
            return new Promise((resolve)=>{
                function checkMaterialsReady() {
                    materials.forEach(function(material) {
                        const materialProperties = properties.get(material);
                        const program = materialProperties.currentProgram;
                        if (program.isReady()) // remove any programs that report they're ready to use from the list
                        materials.delete(material);
                    });
                    // once the list of compiling materials is empty, call the callback
                    if (materials.size === 0) {
                        resolve(scene);
                        return;
                    }
                    // if some materials are still not ready, wait a bit and check again
                    setTimeout(checkMaterialsReady, 10);
                }
                if (extensions.get('KHR_parallel_shader_compile') !== null) // If we can check the compilation status of the materials without
                // blocking then do so right away.
                checkMaterialsReady();
                else // Otherwise start by waiting a bit to give the materials we just
                // initialized a chance to finish.
                setTimeout(checkMaterialsReady, 10);
            });
        };
        // Animation Loop
        let onAnimationFrameCallback = null;
        function onAnimationFrame(time) {
            if (onAnimationFrameCallback) onAnimationFrameCallback(time);
        }
        function onXRSessionStart() {
            animation.stop();
        }
        function onXRSessionEnd() {
            animation.start();
        }
        const animation = new $3dd44ec8564e7230$var$WebGLAnimation();
        animation.setAnimationLoop(onAnimationFrame);
        if (typeof self !== 'undefined') animation.setContext(self);
        this.setAnimationLoop = function(callback) {
            onAnimationFrameCallback = callback;
            xr.setAnimationLoop(callback);
            callback === null ? animation.stop() : animation.start();
        };
        xr.addEventListener('sessionstart', onXRSessionStart);
        xr.addEventListener('sessionend', onXRSessionEnd);
        // Rendering
        this.render = function(scene, camera) {
            if (camera !== undefined && camera.isCamera !== true) {
                console.error('THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.');
                return;
            }
            if (_isContextLost === true) return;
            // update scene graph
            if (scene.matrixWorldAutoUpdate === true) scene.updateMatrixWorld();
            // update camera matrices and frustum
            if (camera.parent === null && camera.matrixWorldAutoUpdate === true) camera.updateMatrixWorld();
            if (xr.enabled === true && xr.isPresenting === true) {
                if (xr.cameraAutoUpdate === true) xr.updateCamera(camera);
                camera = xr.getCamera(); // use XR camera for rendering
            }
            //
            if (scene.isScene === true) scene.onBeforeRender(_this, scene, camera, _currentRenderTarget);
            currentRenderState = renderStates.get(scene, renderStateStack.length);
            currentRenderState.init(camera);
            renderStateStack.push(currentRenderState);
            _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
            _frustum.setFromProjectionMatrix(_projScreenMatrix);
            _localClippingEnabled = this.localClippingEnabled;
            _clippingEnabled = clipping.init(this.clippingPlanes, _localClippingEnabled);
            currentRenderList = renderLists.get(scene, renderListStack.length);
            currentRenderList.init();
            renderListStack.push(currentRenderList);
            if (xr.enabled === true && xr.isPresenting === true) {
                const depthSensingMesh = _this.xr.getDepthSensingMesh();
                if (depthSensingMesh !== null) projectObject(depthSensingMesh, camera, -Infinity, _this.sortObjects);
            }
            projectObject(scene, camera, 0, _this.sortObjects);
            currentRenderList.finish();
            if (_this.sortObjects === true) currentRenderList.sort(_opaqueSort, _transparentSort);
            _renderBackground = xr.enabled === false || xr.isPresenting === false || xr.hasDepthSensing() === false;
            if (_renderBackground) background.addToRenderList(currentRenderList, scene);
            //
            this.info.render.frame++;
            if (_clippingEnabled === true) clipping.beginShadows();
            const shadowsArray = currentRenderState.state.shadowsArray;
            shadowMap.render(shadowsArray, scene, camera);
            if (_clippingEnabled === true) clipping.endShadows();
            //
            if (this.info.autoReset === true) this.info.reset();
            // render scene
            const opaqueObjects = currentRenderList.opaque;
            const transmissiveObjects = currentRenderList.transmissive;
            currentRenderState.setupLights();
            if (camera.isArrayCamera) {
                const cameras = camera.cameras;
                if (transmissiveObjects.length > 0) for(let i = 0, l = cameras.length; i < l; i++){
                    const camera2 = cameras[i];
                    renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera2);
                }
                if (_renderBackground) background.render(scene);
                for(let i = 0, l = cameras.length; i < l; i++){
                    const camera2 = cameras[i];
                    renderScene(currentRenderList, scene, camera2, camera2.viewport);
                }
            } else {
                if (transmissiveObjects.length > 0) renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera);
                if (_renderBackground) background.render(scene);
                renderScene(currentRenderList, scene, camera);
            }
            //
            if (_currentRenderTarget !== null && _currentActiveMipmapLevel === 0) {
                // resolve multisample renderbuffers to a single-sample texture if necessary
                textures.updateMultisampleRenderTarget(_currentRenderTarget);
                // Generate mipmap if we're using any kind of mipmap filtering
                textures.updateRenderTargetMipmap(_currentRenderTarget);
            }
            //
            if (scene.isScene === true) scene.onAfterRender(_this, scene, camera);
            // _gl.finish();
            bindingStates.resetDefaultState();
            _currentMaterialId = -1;
            _currentCamera = null;
            renderStateStack.pop();
            if (renderStateStack.length > 0) {
                currentRenderState = renderStateStack[renderStateStack.length - 1];
                if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, currentRenderState.state.camera);
            } else currentRenderState = null;
            renderListStack.pop();
            if (renderListStack.length > 0) currentRenderList = renderListStack[renderListStack.length - 1];
            else currentRenderList = null;
        };
        function projectObject(object, camera, groupOrder, sortObjects) {
            if (object.visible === false) return;
            const visible = object.layers.test(camera.layers);
            if (visible) {
                if (object.isGroup) groupOrder = object.renderOrder;
                else if (object.isLOD) {
                    if (object.autoUpdate === true) object.update(camera);
                } else if (object.isLight) {
                    currentRenderState.pushLight(object);
                    if (object.castShadow) currentRenderState.pushShadow(object);
                } else if (object.isSprite) {
                    if (!object.frustumCulled || _frustum.intersectsSprite(object)) {
                        if (sortObjects) _vector4.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix);
                        const geometry = objects.update(object);
                        const material = object.material;
                        if (material.visible) currentRenderList.push(object, geometry, material, groupOrder, _vector4.z, null);
                    }
                } else if (object.isMesh || object.isLine || object.isPoints) {
                    if (!object.frustumCulled || _frustum.intersectsObject(object)) {
                        const geometry = objects.update(object);
                        const material = object.material;
                        if (sortObjects) {
                            if (object.boundingSphere !== undefined) {
                                if (object.boundingSphere === null) object.computeBoundingSphere();
                                _vector4.copy(object.boundingSphere.center);
                            } else {
                                if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
                                _vector4.copy(geometry.boundingSphere.center);
                            }
                            _vector4.applyMatrix4(object.matrixWorld).applyMatrix4(_projScreenMatrix);
                        }
                        if (Array.isArray(material)) {
                            const groups = geometry.groups;
                            for(let i = 0, l = groups.length; i < l; i++){
                                const group = groups[i];
                                const groupMaterial = material[group.materialIndex];
                                if (groupMaterial && groupMaterial.visible) currentRenderList.push(object, geometry, groupMaterial, groupOrder, _vector4.z, group);
                            }
                        } else if (material.visible) currentRenderList.push(object, geometry, material, groupOrder, _vector4.z, null);
                    }
                }
            }
            const children = object.children;
            for(let i = 0, l = children.length; i < l; i++)projectObject(children[i], camera, groupOrder, sortObjects);
        }
        function renderScene(currentRenderList, scene, camera, viewport) {
            const opaqueObjects = currentRenderList.opaque;
            const transmissiveObjects = currentRenderList.transmissive;
            const transparentObjects = currentRenderList.transparent;
            currentRenderState.setupLightsView(camera);
            if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, camera);
            if (viewport) state.viewport(_currentViewport.copy(viewport));
            if (opaqueObjects.length > 0) renderObjects(opaqueObjects, scene, camera);
            if (transmissiveObjects.length > 0) renderObjects(transmissiveObjects, scene, camera);
            if (transparentObjects.length > 0) renderObjects(transparentObjects, scene, camera);
            // Ensure depth buffer writing is enabled so it can be cleared on next render
            state.buffers.depth.setTest(true);
            state.buffers.depth.setMask(true);
            state.buffers.color.setMask(true);
            state.setPolygonOffset(false);
        }
        function renderTransmissionPass(opaqueObjects, transmissiveObjects, scene, camera) {
            const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
            if (overrideMaterial !== null) return;
            if (currentRenderState.state.transmissionRenderTarget[camera.id] === undefined) currentRenderState.state.transmissionRenderTarget[camera.id] = new (0, $d5b85d29c0b78636$export$3c052beb2e51e23f)(1, 1, {
                generateMipmaps: true,
                type: extensions.has('EXT_color_buffer_half_float') || extensions.has('EXT_color_buffer_float') ? (0, $d5b85d29c0b78636$export$2697304443f382bc) : (0, $d5b85d29c0b78636$export$2e8ce08d3f6f5e10),
                minFilter: (0, $d5b85d29c0b78636$export$5d8599b6a933fb1b),
                samples: 4,
                stencilBuffer: stencil,
                resolveDepthBuffer: false,
                resolveStencilBuffer: false,
                colorSpace: (0, $d5b85d29c0b78636$export$5e6fd513f44698c).workingColorSpace
            });
            const transmissionRenderTarget = currentRenderState.state.transmissionRenderTarget[camera.id];
            const activeViewport = camera.viewport || _currentViewport;
            transmissionRenderTarget.setSize(activeViewport.z * _this.transmissionResolutionScale, activeViewport.w * _this.transmissionResolutionScale);
            //
            const currentRenderTarget = _this.getRenderTarget();
            _this.setRenderTarget(transmissionRenderTarget);
            _this.getClearColor(_currentClearColor);
            _currentClearAlpha = _this.getClearAlpha();
            if (_currentClearAlpha < 1) _this.setClearColor(0xffffff, 0.5);
            _this.clear();
            if (_renderBackground) background.render(scene);
            // Turn off the features which can affect the frag color for opaque objects pass.
            // Otherwise they are applied twice in opaque objects pass and transmission objects pass.
            const currentToneMapping = _this.toneMapping;
            _this.toneMapping = (0, $d5b85d29c0b78636$export$9fcb6b4294603b2);
            // Remove viewport from camera to avoid nested render calls resetting viewport to it (e.g Reflector).
            // Transmission render pass requires viewport to match the transmissionRenderTarget.
            const currentCameraViewport = camera.viewport;
            if (camera.viewport !== undefined) camera.viewport = undefined;
            currentRenderState.setupLightsView(camera);
            if (_clippingEnabled === true) clipping.setGlobalState(_this.clippingPlanes, camera);
            renderObjects(opaqueObjects, scene, camera);
            textures.updateMultisampleRenderTarget(transmissionRenderTarget);
            textures.updateRenderTargetMipmap(transmissionRenderTarget);
            if (extensions.has('WEBGL_multisampled_render_to_texture') === false) {
                let renderTargetNeedsUpdate = false;
                for(let i = 0, l = transmissiveObjects.length; i < l; i++){
                    const renderItem = transmissiveObjects[i];
                    const object = renderItem.object;
                    const geometry = renderItem.geometry;
                    const material = renderItem.material;
                    const group = renderItem.group;
                    if (material.side === (0, $d5b85d29c0b78636$export$3b296b6f144d5b03) && object.layers.test(camera.layers)) {
                        const currentSide = material.side;
                        material.side = (0, $d5b85d29c0b78636$export$d9f0486e75b5ace);
                        material.needsUpdate = true;
                        renderObject(object, scene, camera, geometry, material, group);
                        material.side = currentSide;
                        material.needsUpdate = true;
                        renderTargetNeedsUpdate = true;
                    }
                }
                if (renderTargetNeedsUpdate === true) {
                    textures.updateMultisampleRenderTarget(transmissionRenderTarget);
                    textures.updateRenderTargetMipmap(transmissionRenderTarget);
                }
            }
            _this.setRenderTarget(currentRenderTarget);
            _this.setClearColor(_currentClearColor, _currentClearAlpha);
            if (currentCameraViewport !== undefined) camera.viewport = currentCameraViewport;
            _this.toneMapping = currentToneMapping;
        }
        function renderObjects(renderList, scene, camera) {
            const overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null;
            for(let i = 0, l = renderList.length; i < l; i++){
                const renderItem = renderList[i];
                const object = renderItem.object;
                const geometry = renderItem.geometry;
                const material = overrideMaterial === null ? renderItem.material : overrideMaterial;
                const group = renderItem.group;
                if (object.layers.test(camera.layers)) renderObject(object, scene, camera, geometry, material, group);
            }
        }
        function renderObject(object, scene, camera, geometry, material, group) {
            object.onBeforeRender(_this, scene, camera, geometry, material, group);
            object.modelViewMatrix.multiplyMatrices(camera.matrixWorldInverse, object.matrixWorld);
            object.normalMatrix.getNormalMatrix(object.modelViewMatrix);
            material.onBeforeRender(_this, scene, camera, geometry, object, group);
            if (material.transparent === true && material.side === (0, $d5b85d29c0b78636$export$3b296b6f144d5b03) && material.forceSinglePass === false) {
                material.side = (0, $d5b85d29c0b78636$export$d9f0486e75b5ace);
                material.needsUpdate = true;
                _this.renderBufferDirect(camera, scene, geometry, material, object, group);
                material.side = (0, $d5b85d29c0b78636$export$2ede184fc2998901);
                material.needsUpdate = true;
                _this.renderBufferDirect(camera, scene, geometry, material, object, group);
                material.side = (0, $d5b85d29c0b78636$export$3b296b6f144d5b03);
            } else _this.renderBufferDirect(camera, scene, geometry, material, object, group);
            object.onAfterRender(_this, scene, camera, geometry, material, group);
        }
        function getProgram(material, scene, object) {
            if (scene.isScene !== true) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
            const materialProperties = properties.get(material);
            const lights = currentRenderState.state.lights;
            const shadowsArray = currentRenderState.state.shadowsArray;
            const lightsStateVersion = lights.state.version;
            const parameters = programCache.getParameters(material, lights.state, shadowsArray, scene, object);
            const programCacheKey = programCache.getProgramCacheKey(parameters);
            let programs = materialProperties.programs;
            // always update environment and fog - changing these trigger an getProgram call, but it's possible that the program doesn't change
            materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
            materialProperties.fog = scene.fog;
            materialProperties.envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || materialProperties.environment);
            materialProperties.envMapRotation = materialProperties.environment !== null && material.envMap === null ? scene.environmentRotation : material.envMapRotation;
            if (programs === undefined) {
                // new material
                material.addEventListener('dispose', onMaterialDispose);
                programs = new Map();
                materialProperties.programs = programs;
            }
            let program = programs.get(programCacheKey);
            if (program !== undefined) // early out if program and light state is identical
            {
                if (materialProperties.currentProgram === program && materialProperties.lightsStateVersion === lightsStateVersion) {
                    updateCommonMaterialProperties(material, parameters);
                    return program;
                }
            } else {
                parameters.uniforms = programCache.getUniforms(material);
                material.onBeforeCompile(parameters, _this);
                program = programCache.acquireProgram(parameters, programCacheKey);
                programs.set(programCacheKey, program);
                materialProperties.uniforms = parameters.uniforms;
            }
            const uniforms = materialProperties.uniforms;
            if (!material.isShaderMaterial && !material.isRawShaderMaterial || material.clipping === true) uniforms.clippingPlanes = clipping.uniform;
            updateCommonMaterialProperties(material, parameters);
            // store the light setup it was created for
            materialProperties.needsLights = materialNeedsLights(material);
            materialProperties.lightsStateVersion = lightsStateVersion;
            if (materialProperties.needsLights) {
                // wire up the material to this renderer's lighting state
                uniforms.ambientLightColor.value = lights.state.ambient;
                uniforms.lightProbe.value = lights.state.probe;
                uniforms.directionalLights.value = lights.state.directional;
                uniforms.directionalLightShadows.value = lights.state.directionalShadow;
                uniforms.spotLights.value = lights.state.spot;
                uniforms.spotLightShadows.value = lights.state.spotShadow;
                uniforms.rectAreaLights.value = lights.state.rectArea;
                uniforms.ltc_1.value = lights.state.rectAreaLTC1;
                uniforms.ltc_2.value = lights.state.rectAreaLTC2;
                uniforms.pointLights.value = lights.state.point;
                uniforms.pointLightShadows.value = lights.state.pointShadow;
                uniforms.hemisphereLights.value = lights.state.hemi;
                uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
                uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
                uniforms.spotShadowMap.value = lights.state.spotShadowMap;
                uniforms.spotLightMatrix.value = lights.state.spotLightMatrix;
                uniforms.spotLightMap.value = lights.state.spotLightMap;
                uniforms.pointShadowMap.value = lights.state.pointShadowMap;
                uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
            // TODO (abelnation): add area lights shadow info to uniforms
            }
            materialProperties.currentProgram = program;
            materialProperties.uniformsList = null;
            return program;
        }
        function getUniformList(materialProperties) {
            if (materialProperties.uniformsList === null) {
                const progUniforms = materialProperties.currentProgram.getUniforms();
                materialProperties.uniformsList = $3dd44ec8564e7230$var$WebGLUniforms.seqWithValue(progUniforms.seq, materialProperties.uniforms);
            }
            return materialProperties.uniformsList;
        }
        function updateCommonMaterialProperties(material, parameters) {
            const materialProperties = properties.get(material);
            materialProperties.outputColorSpace = parameters.outputColorSpace;
            materialProperties.batching = parameters.batching;
            materialProperties.batchingColor = parameters.batchingColor;
            materialProperties.instancing = parameters.instancing;
            materialProperties.instancingColor = parameters.instancingColor;
            materialProperties.instancingMorph = parameters.instancingMorph;
            materialProperties.skinning = parameters.skinning;
            materialProperties.morphTargets = parameters.morphTargets;
            materialProperties.morphNormals = parameters.morphNormals;
            materialProperties.morphColors = parameters.morphColors;
            materialProperties.morphTargetsCount = parameters.morphTargetsCount;
            materialProperties.numClippingPlanes = parameters.numClippingPlanes;
            materialProperties.numIntersection = parameters.numClipIntersection;
            materialProperties.vertexAlphas = parameters.vertexAlphas;
            materialProperties.vertexTangents = parameters.vertexTangents;
            materialProperties.toneMapping = parameters.toneMapping;
        }
        function setProgram(camera, scene, geometry, material, object) {
            if (scene.isScene !== true) scene = _emptyScene; // scene could be a Mesh, Line, Points, ...
            textures.resetTextureUnits();
            const fog = scene.fog;
            const environment = material.isMeshStandardMaterial ? scene.environment : null;
            const colorSpace = _currentRenderTarget === null ? _this.outputColorSpace : _currentRenderTarget.isXRRenderTarget === true ? _currentRenderTarget.texture.colorSpace : (0, $d5b85d29c0b78636$export$42429b3acfb233a4);
            const envMap = (material.isMeshStandardMaterial ? cubeuvmaps : cubemaps).get(material.envMap || environment);
            const vertexAlphas = material.vertexColors === true && !!geometry.attributes.color && geometry.attributes.color.itemSize === 4;
            const vertexTangents = !!geometry.attributes.tangent && (!!material.normalMap || material.anisotropy > 0);
            const morphTargets = !!geometry.morphAttributes.position;
            const morphNormals = !!geometry.morphAttributes.normal;
            const morphColors = !!geometry.morphAttributes.color;
            let toneMapping = (0, $d5b85d29c0b78636$export$9fcb6b4294603b2);
            if (material.toneMapped) {
                if (_currentRenderTarget === null || _currentRenderTarget.isXRRenderTarget === true) toneMapping = _this.toneMapping;
            }
            const morphAttribute = geometry.morphAttributes.position || geometry.morphAttributes.normal || geometry.morphAttributes.color;
            const morphTargetsCount = morphAttribute !== undefined ? morphAttribute.length : 0;
            const materialProperties = properties.get(material);
            const lights = currentRenderState.state.lights;
            if (_clippingEnabled === true) {
                if (_localClippingEnabled === true || camera !== _currentCamera) {
                    const useCache = camera === _currentCamera && material.id === _currentMaterialId;
                    // we might want to call this function with some ClippingGroup
                    // object instead of the material, once it becomes feasible
                    // (#8465, #8379)
                    clipping.setState(material, camera, useCache);
                }
            }
            //
            let needsProgramChange = false;
            if (material.version === materialProperties.__version) {
                if (materialProperties.needsLights && materialProperties.lightsStateVersion !== lights.state.version) needsProgramChange = true;
                else if (materialProperties.outputColorSpace !== colorSpace) needsProgramChange = true;
                else if (object.isBatchedMesh && materialProperties.batching === false) needsProgramChange = true;
                else if (!object.isBatchedMesh && materialProperties.batching === true) needsProgramChange = true;
                else if (object.isBatchedMesh && materialProperties.batchingColor === true && object.colorTexture === null) needsProgramChange = true;
                else if (object.isBatchedMesh && materialProperties.batchingColor === false && object.colorTexture !== null) needsProgramChange = true;
                else if (object.isInstancedMesh && materialProperties.instancing === false) needsProgramChange = true;
                else if (!object.isInstancedMesh && materialProperties.instancing === true) needsProgramChange = true;
                else if (object.isSkinnedMesh && materialProperties.skinning === false) needsProgramChange = true;
                else if (!object.isSkinnedMesh && materialProperties.skinning === true) needsProgramChange = true;
                else if (object.isInstancedMesh && materialProperties.instancingColor === true && object.instanceColor === null) needsProgramChange = true;
                else if (object.isInstancedMesh && materialProperties.instancingColor === false && object.instanceColor !== null) needsProgramChange = true;
                else if (object.isInstancedMesh && materialProperties.instancingMorph === true && object.morphTexture === null) needsProgramChange = true;
                else if (object.isInstancedMesh && materialProperties.instancingMorph === false && object.morphTexture !== null) needsProgramChange = true;
                else if (materialProperties.envMap !== envMap) needsProgramChange = true;
                else if (material.fog === true && materialProperties.fog !== fog) needsProgramChange = true;
                else if (materialProperties.numClippingPlanes !== undefined && (materialProperties.numClippingPlanes !== clipping.numPlanes || materialProperties.numIntersection !== clipping.numIntersection)) needsProgramChange = true;
                else if (materialProperties.vertexAlphas !== vertexAlphas) needsProgramChange = true;
                else if (materialProperties.vertexTangents !== vertexTangents) needsProgramChange = true;
                else if (materialProperties.morphTargets !== morphTargets) needsProgramChange = true;
                else if (materialProperties.morphNormals !== morphNormals) needsProgramChange = true;
                else if (materialProperties.morphColors !== morphColors) needsProgramChange = true;
                else if (materialProperties.toneMapping !== toneMapping) needsProgramChange = true;
                else if (materialProperties.morphTargetsCount !== morphTargetsCount) needsProgramChange = true;
            } else {
                needsProgramChange = true;
                materialProperties.__version = material.version;
            }
            //
            let program = materialProperties.currentProgram;
            if (needsProgramChange === true) program = getProgram(material, scene, object);
            let refreshProgram = false;
            let refreshMaterial = false;
            let refreshLights = false;
            const p_uniforms = program.getUniforms(), m_uniforms = materialProperties.uniforms;
            if (state.useProgram(program.program)) {
                refreshProgram = true;
                refreshMaterial = true;
                refreshLights = true;
            }
            if (material.id !== _currentMaterialId) {
                _currentMaterialId = material.id;
                refreshMaterial = true;
            }
            if (refreshProgram || _currentCamera !== camera) {
                // common camera uniforms
                const reverseDepthBuffer = state.buffers.depth.getReversed();
                if (reverseDepthBuffer) {
                    _currentProjectionMatrix.copy(camera.projectionMatrix);
                    (0, $d5b85d29c0b78636$export$5238391f68c729b)(_currentProjectionMatrix);
                    (0, $d5b85d29c0b78636$export$f8cf97d08da9bc86)(_currentProjectionMatrix);
                    p_uniforms.setValue(_gl, 'projectionMatrix', _currentProjectionMatrix);
                } else p_uniforms.setValue(_gl, 'projectionMatrix', camera.projectionMatrix);
                p_uniforms.setValue(_gl, 'viewMatrix', camera.matrixWorldInverse);
                const uCamPos = p_uniforms.map.cameraPosition;
                if (uCamPos !== undefined) uCamPos.setValue(_gl, _vector3.setFromMatrixPosition(camera.matrixWorld));
                if (capabilities.logarithmicDepthBuffer) p_uniforms.setValue(_gl, 'logDepthBufFC', 2.0 / (Math.log(camera.far + 1.0) / Math.LN2));
                // consider moving isOrthographic to UniformLib and WebGLMaterials, see https://github.com/mrdoob/three.js/pull/26467#issuecomment-1645185067
                if (material.isMeshPhongMaterial || material.isMeshToonMaterial || material.isMeshLambertMaterial || material.isMeshBasicMaterial || material.isMeshStandardMaterial || material.isShaderMaterial) p_uniforms.setValue(_gl, 'isOrthographic', camera.isOrthographicCamera === true);
                if (_currentCamera !== camera) {
                    _currentCamera = camera;
                    // lighting uniforms depend on the camera so enforce an update
                    // now, in case this material supports lights - or later, when
                    // the next material that does gets activated:
                    refreshMaterial = true; // set to true on material change
                    refreshLights = true; // remains set until update done
                }
            }
            // skinning and morph target uniforms must be set even if material didn't change
            // auto-setting of texture unit for bone and morph texture must go before other textures
            // otherwise textures used for skinning and morphing can take over texture units reserved for other material textures
            if (object.isSkinnedMesh) {
                p_uniforms.setOptional(_gl, object, 'bindMatrix');
                p_uniforms.setOptional(_gl, object, 'bindMatrixInverse');
                const skeleton = object.skeleton;
                if (skeleton) {
                    if (skeleton.boneTexture === null) skeleton.computeBoneTexture();
                    p_uniforms.setValue(_gl, 'boneTexture', skeleton.boneTexture, textures);
                }
            }
            if (object.isBatchedMesh) {
                p_uniforms.setOptional(_gl, object, 'batchingTexture');
                p_uniforms.setValue(_gl, 'batchingTexture', object._matricesTexture, textures);
                p_uniforms.setOptional(_gl, object, 'batchingIdTexture');
                p_uniforms.setValue(_gl, 'batchingIdTexture', object._indirectTexture, textures);
                p_uniforms.setOptional(_gl, object, 'batchingColorTexture');
                if (object._colorsTexture !== null) p_uniforms.setValue(_gl, 'batchingColorTexture', object._colorsTexture, textures);
            }
            const morphAttributes = geometry.morphAttributes;
            if (morphAttributes.position !== undefined || morphAttributes.normal !== undefined || morphAttributes.color !== undefined) morphtargets.update(object, geometry, program);
            if (refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow) {
                materialProperties.receiveShadow = object.receiveShadow;
                p_uniforms.setValue(_gl, 'receiveShadow', object.receiveShadow);
            }
            // https://github.com/mrdoob/three.js/pull/24467#issuecomment-1209031512
            if (material.isMeshGouraudMaterial && material.envMap !== null) {
                m_uniforms.envMap.value = envMap;
                m_uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap.isRenderTargetTexture === false ? -1 : 1;
            }
            if (material.isMeshStandardMaterial && material.envMap === null && scene.environment !== null) m_uniforms.envMapIntensity.value = scene.environmentIntensity;
            if (refreshMaterial) {
                p_uniforms.setValue(_gl, 'toneMappingExposure', _this.toneMappingExposure);
                if (materialProperties.needsLights) // the current material requires lighting info
                // note: all lighting uniforms are always set correctly
                // they simply reference the renderer's state for their
                // values
                //
                // use the current material's .needsUpdate flags to set
                // the GL state when required
                markUniformsLightsNeedsUpdate(m_uniforms, refreshLights);
                // refresh uniforms common to several materials
                if (fog && material.fog === true) materials.refreshFogUniforms(m_uniforms, fog);
                materials.refreshMaterialUniforms(m_uniforms, material, _pixelRatio, _height, currentRenderState.state.transmissionRenderTarget[camera.id]);
                $3dd44ec8564e7230$var$WebGLUniforms.upload(_gl, getUniformList(materialProperties), m_uniforms, textures);
            }
            if (material.isShaderMaterial && material.uniformsNeedUpdate === true) {
                $3dd44ec8564e7230$var$WebGLUniforms.upload(_gl, getUniformList(materialProperties), m_uniforms, textures);
                material.uniformsNeedUpdate = false;
            }
            if (material.isSpriteMaterial) p_uniforms.setValue(_gl, 'center', object.center);
            // common matrices
            p_uniforms.setValue(_gl, 'modelViewMatrix', object.modelViewMatrix);
            p_uniforms.setValue(_gl, 'normalMatrix', object.normalMatrix);
            p_uniforms.setValue(_gl, 'modelMatrix', object.matrixWorld);
            // UBOs
            if (material.isShaderMaterial || material.isRawShaderMaterial) {
                const groups = material.uniformsGroups;
                for(let i = 0, l = groups.length; i < l; i++){
                    const group = groups[i];
                    uniformsGroups.update(group, program);
                    uniformsGroups.bind(group, program);
                }
            }
            return program;
        }
        // If uniforms are marked as clean, they don't need to be loaded to the GPU.
        function markUniformsLightsNeedsUpdate(uniforms, value) {
            uniforms.ambientLightColor.needsUpdate = value;
            uniforms.lightProbe.needsUpdate = value;
            uniforms.directionalLights.needsUpdate = value;
            uniforms.directionalLightShadows.needsUpdate = value;
            uniforms.pointLights.needsUpdate = value;
            uniforms.pointLightShadows.needsUpdate = value;
            uniforms.spotLights.needsUpdate = value;
            uniforms.spotLightShadows.needsUpdate = value;
            uniforms.rectAreaLights.needsUpdate = value;
            uniforms.hemisphereLights.needsUpdate = value;
        }
        function materialNeedsLights(material) {
            return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial || material.isMeshStandardMaterial || material.isShadowMaterial || material.isShaderMaterial && material.lights === true;
        }
        this.getActiveCubeFace = function() {
            return _currentActiveCubeFace;
        };
        this.getActiveMipmapLevel = function() {
            return _currentActiveMipmapLevel;
        };
        this.getRenderTarget = function() {
            return _currentRenderTarget;
        };
        this.setRenderTargetTextures = function(renderTarget, colorTexture, depthTexture) {
            properties.get(renderTarget.texture).__webglTexture = colorTexture;
            properties.get(renderTarget.depthTexture).__webglTexture = depthTexture;
            const renderTargetProperties = properties.get(renderTarget);
            renderTargetProperties.__hasExternalTextures = true;
            renderTargetProperties.__autoAllocateDepthBuffer = depthTexture === undefined;
            if (!renderTargetProperties.__autoAllocateDepthBuffer) // The multisample_render_to_texture extension doesn't work properly if there
            // are midframe flushes and an external depth buffer. Disable use of the extension.
            {
                if (extensions.has('WEBGL_multisampled_render_to_texture') === true) {
                    console.warn('THREE.WebGLRenderer: Render-to-texture extension was disabled because an external texture was provided');
                    renderTargetProperties.__useRenderToTexture = false;
                }
            }
        };
        this.setRenderTargetFramebuffer = function(renderTarget, defaultFramebuffer) {
            const renderTargetProperties = properties.get(renderTarget);
            renderTargetProperties.__webglFramebuffer = defaultFramebuffer;
            renderTargetProperties.__useDefaultFramebuffer = defaultFramebuffer === undefined;
        };
        const _scratchFrameBuffer = _gl.createFramebuffer();
        this.setRenderTarget = function(renderTarget, activeCubeFace = 0, activeMipmapLevel = 0) {
            _currentRenderTarget = renderTarget;
            _currentActiveCubeFace = activeCubeFace;
            _currentActiveMipmapLevel = activeMipmapLevel;
            let useDefaultFramebuffer = true;
            let framebuffer = null;
            let isCube = false;
            let isRenderTarget3D = false;
            if (renderTarget) {
                const renderTargetProperties = properties.get(renderTarget);
                if (renderTargetProperties.__useDefaultFramebuffer !== undefined) {
                    // We need to make sure to rebind the framebuffer.
                    state.bindFramebuffer(_gl.FRAMEBUFFER, null);
                    useDefaultFramebuffer = false;
                } else if (renderTargetProperties.__webglFramebuffer === undefined) textures.setupRenderTarget(renderTarget);
                else if (renderTargetProperties.__hasExternalTextures) // Color and depth texture must be rebound in order for the swapchain to update.
                textures.rebindTextures(renderTarget, properties.get(renderTarget.texture).__webglTexture, properties.get(renderTarget.depthTexture).__webglTexture);
                else if (renderTarget.depthBuffer) {
                    // check if the depth texture is already bound to the frame buffer and that it's been initialized
                    const depthTexture = renderTarget.depthTexture;
                    if (renderTargetProperties.__boundDepthTexture !== depthTexture) {
                        // check if the depth texture is compatible
                        if (depthTexture !== null && properties.has(depthTexture) && (renderTarget.width !== depthTexture.image.width || renderTarget.height !== depthTexture.image.height)) throw new Error('WebGLRenderTarget: Attached DepthTexture is initialized to the incorrect size.');
                        // Swap the depth buffer to the currently attached one
                        textures.setupDepthRenderbuffer(renderTarget);
                    }
                }
                const texture = renderTarget.texture;
                if (texture.isData3DTexture || texture.isDataArrayTexture || texture.isCompressedArrayTexture) isRenderTarget3D = true;
                const __webglFramebuffer = properties.get(renderTarget).__webglFramebuffer;
                if (renderTarget.isWebGLCubeRenderTarget) {
                    if (Array.isArray(__webglFramebuffer[activeCubeFace])) framebuffer = __webglFramebuffer[activeCubeFace][activeMipmapLevel];
                    else framebuffer = __webglFramebuffer[activeCubeFace];
                    isCube = true;
                } else if (renderTarget.samples > 0 && textures.useMultisampledRTT(renderTarget) === false) framebuffer = properties.get(renderTarget).__webglMultisampledFramebuffer;
                else if (Array.isArray(__webglFramebuffer)) framebuffer = __webglFramebuffer[activeMipmapLevel];
                else framebuffer = __webglFramebuffer;
                _currentViewport.copy(renderTarget.viewport);
                _currentScissor.copy(renderTarget.scissor);
                _currentScissorTest = renderTarget.scissorTest;
            } else {
                _currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor();
                _currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor();
                _currentScissorTest = _scissorTest;
            }
            // Use a scratch frame buffer if rendering to a mip level to avoid depth buffers
            // being bound that are different sizes.
            if (activeMipmapLevel !== 0) framebuffer = _scratchFrameBuffer;
            const framebufferBound = state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
            if (framebufferBound && useDefaultFramebuffer) state.drawBuffers(renderTarget, framebuffer);
            state.viewport(_currentViewport);
            state.scissor(_currentScissor);
            state.setScissorTest(_currentScissorTest);
            if (isCube) {
                const textureProperties = properties.get(renderTarget.texture);
                _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel);
            } else if (isRenderTarget3D) {
                const textureProperties = properties.get(renderTarget.texture);
                const layer = activeCubeFace;
                _gl.framebufferTextureLayer(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, textureProperties.__webglTexture, activeMipmapLevel, layer);
            } else if (renderTarget !== null && activeMipmapLevel !== 0) {
                // Only bind the frame buffer if we are using a scratch frame buffer to render to a mipmap.
                // If we rebind the texture when using a multi sample buffer then an error about inconsistent samples will be thrown.
                const textureProperties = properties.get(renderTarget.texture);
                _gl.framebufferTexture2D(_gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, textureProperties.__webglTexture, activeMipmapLevel);
            }
            _currentMaterialId = -1; // reset current material to ensure correct uniform bindings
        };
        this.readRenderTargetPixels = function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex) {
            if (!(renderTarget && renderTarget.isWebGLRenderTarget)) {
                console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.');
                return;
            }
            let framebuffer = properties.get(renderTarget).__webglFramebuffer;
            if (renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined) framebuffer = framebuffer[activeCubeFaceIndex];
            if (framebuffer) {
                state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
                try {
                    const texture = renderTarget.texture;
                    const textureFormat = texture.format;
                    const textureType = texture.type;
                    if (!capabilities.textureFormatReadable(textureFormat)) {
                        console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.');
                        return;
                    }
                    if (!capabilities.textureTypeReadable(textureType)) {
                        console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.');
                        return;
                    }
                    // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
                    if (x >= 0 && x <= renderTarget.width - width && y >= 0 && y <= renderTarget.height - height) _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), buffer);
                } finally{
                    // restore framebuffer of current render target if necessary
                    const framebuffer = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null;
                    state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
                }
            }
        };
        this.readRenderTargetPixelsAsync = async function(renderTarget, x, y, width, height, buffer, activeCubeFaceIndex) {
            if (!(renderTarget && renderTarget.isWebGLRenderTarget)) throw new Error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.');
            let framebuffer = properties.get(renderTarget).__webglFramebuffer;
            if (renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined) framebuffer = framebuffer[activeCubeFaceIndex];
            if (framebuffer) {
                const texture = renderTarget.texture;
                const textureFormat = texture.format;
                const textureType = texture.type;
                if (!capabilities.textureFormatReadable(textureFormat)) throw new Error('THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in RGBA or implementation defined format.');
                if (!capabilities.textureTypeReadable(textureType)) throw new Error('THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in UnsignedByteType or implementation defined type.');
                // the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
                if (x >= 0 && x <= renderTarget.width - width && y >= 0 && y <= renderTarget.height - height) {
                    // set the active frame buffer to the one we want to read
                    state.bindFramebuffer(_gl.FRAMEBUFFER, framebuffer);
                    const glBuffer = _gl.createBuffer();
                    _gl.bindBuffer(_gl.PIXEL_PACK_BUFFER, glBuffer);
                    _gl.bufferData(_gl.PIXEL_PACK_BUFFER, buffer.byteLength, _gl.STREAM_READ);
                    _gl.readPixels(x, y, width, height, utils.convert(textureFormat), utils.convert(textureType), 0);
                    // reset the frame buffer to the currently set buffer before waiting
                    const currFramebuffer = _currentRenderTarget !== null ? properties.get(_currentRenderTarget).__webglFramebuffer : null;
                    state.bindFramebuffer(_gl.FRAMEBUFFER, currFramebuffer);
                    // check if the commands have finished every 8 ms
                    const sync = _gl.fenceSync(_gl.SYNC_GPU_COMMANDS_COMPLETE, 0);
                    _gl.flush();
                    await (0, $d5b85d29c0b78636$export$d43f91ebeafb2c7)(_gl, sync, 4);
                    // read the data and delete the buffer
                    _gl.bindBuffer(_gl.PIXEL_PACK_BUFFER, glBuffer);
                    _gl.getBufferSubData(_gl.PIXEL_PACK_BUFFER, 0, buffer);
                    _gl.deleteBuffer(glBuffer);
                    _gl.deleteSync(sync);
                    return buffer;
                } else throw new Error('THREE.WebGLRenderer.readRenderTargetPixelsAsync: requested read bounds are out of range.');
            }
        };
        this.copyFramebufferToTexture = function(texture, position = null, level = 0) {
            // support previous signature with position first
            if (texture.isTexture !== true) {
                // @deprecated, r165
                (0, $d5b85d29c0b78636$export$5b28268982f175ba)('WebGLRenderer: copyFramebufferToTexture function signature has changed.');
                position = arguments[0] || null;
                texture = arguments[1];
            }
            const levelScale = Math.pow(2, -level);
            const width = Math.floor(texture.image.width * levelScale);
            const height = Math.floor(texture.image.height * levelScale);
            const x = position !== null ? position.x : 0;
            const y = position !== null ? position.y : 0;
            textures.setTexture2D(texture, 0);
            _gl.copyTexSubImage2D(_gl.TEXTURE_2D, level, 0, 0, x, y, width, height);
            state.unbindTexture();
        };
        const _srcFramebuffer = _gl.createFramebuffer();
        const _dstFramebuffer = _gl.createFramebuffer();
        this.copyTextureToTexture = function(srcTexture, dstTexture, srcRegion = null, dstPosition = null, srcLevel = 0, dstLevel = null) {
            // support previous signature with dstPosition first
            if (srcTexture.isTexture !== true) {
                // @deprecated, r165
                (0, $d5b85d29c0b78636$export$5b28268982f175ba)('WebGLRenderer: copyTextureToTexture function signature has changed.');
                dstPosition = arguments[0] || null;
                srcTexture = arguments[1];
                dstTexture = arguments[2];
                dstLevel = arguments[3] || 0;
                srcRegion = null;
            }
            // support the previous signature with just a single dst mipmap level
            if (dstLevel === null) {
                if (srcLevel !== 0) {
                    // @deprecated, r171
                    (0, $d5b85d29c0b78636$export$5b28268982f175ba)('WebGLRenderer: copyTextureToTexture function signature has changed to support src and dst mipmap levels.');
                    dstLevel = srcLevel;
                    srcLevel = 0;
                } else dstLevel = 0;
            }
            // gather the necessary dimensions to copy
            let width, height, depth, minX, minY, minZ;
            let dstX, dstY, dstZ;
            const image = srcTexture.isCompressedTexture ? srcTexture.mipmaps[dstLevel] : srcTexture.image;
            if (srcRegion !== null) {
                width = srcRegion.max.x - srcRegion.min.x;
                height = srcRegion.max.y - srcRegion.min.y;
                depth = srcRegion.isBox3 ? srcRegion.max.z - srcRegion.min.z : 1;
                minX = srcRegion.min.x;
                minY = srcRegion.min.y;
                minZ = srcRegion.isBox3 ? srcRegion.min.z : 0;
            } else {
                const levelScale = Math.pow(2, -srcLevel);
                width = Math.floor(image.width * levelScale);
                height = Math.floor(image.height * levelScale);
                if (srcTexture.isDataArrayTexture) depth = image.depth;
                else if (srcTexture.isData3DTexture) depth = Math.floor(image.depth * levelScale);
                else depth = 1;
                minX = 0;
                minY = 0;
                minZ = 0;
            }
            if (dstPosition !== null) {
                dstX = dstPosition.x;
                dstY = dstPosition.y;
                dstZ = dstPosition.z;
            } else {
                dstX = 0;
                dstY = 0;
                dstZ = 0;
            }
            // Set up the destination target
            const glFormat = utils.convert(dstTexture.format);
            const glType = utils.convert(dstTexture.type);
            let glTarget;
            if (dstTexture.isData3DTexture) {
                textures.setTexture3D(dstTexture, 0);
                glTarget = _gl.TEXTURE_3D;
            } else if (dstTexture.isDataArrayTexture || dstTexture.isCompressedArrayTexture) {
                textures.setTexture2DArray(dstTexture, 0);
                glTarget = _gl.TEXTURE_2D_ARRAY;
            } else {
                textures.setTexture2D(dstTexture, 0);
                glTarget = _gl.TEXTURE_2D;
            }
            _gl.pixelStorei(_gl.UNPACK_FLIP_Y_WEBGL, dstTexture.flipY);
            _gl.pixelStorei(_gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, dstTexture.premultiplyAlpha);
            _gl.pixelStorei(_gl.UNPACK_ALIGNMENT, dstTexture.unpackAlignment);
            // used for copying data from cpu
            const currentUnpackRowLen = _gl.getParameter(_gl.UNPACK_ROW_LENGTH);
            const currentUnpackImageHeight = _gl.getParameter(_gl.UNPACK_IMAGE_HEIGHT);
            const currentUnpackSkipPixels = _gl.getParameter(_gl.UNPACK_SKIP_PIXELS);
            const currentUnpackSkipRows = _gl.getParameter(_gl.UNPACK_SKIP_ROWS);
            const currentUnpackSkipImages = _gl.getParameter(_gl.UNPACK_SKIP_IMAGES);
            _gl.pixelStorei(_gl.UNPACK_ROW_LENGTH, image.width);
            _gl.pixelStorei(_gl.UNPACK_IMAGE_HEIGHT, image.height);
            _gl.pixelStorei(_gl.UNPACK_SKIP_PIXELS, minX);
            _gl.pixelStorei(_gl.UNPACK_SKIP_ROWS, minY);
            _gl.pixelStorei(_gl.UNPACK_SKIP_IMAGES, minZ);
            // set up the src texture
            const isSrc3D = srcTexture.isDataArrayTexture || srcTexture.isData3DTexture;
            const isDst3D = dstTexture.isDataArrayTexture || dstTexture.isData3DTexture;
            if (srcTexture.isDepthTexture) {
                const srcTextureProperties = properties.get(srcTexture);
                const dstTextureProperties = properties.get(dstTexture);
                const srcRenderTargetProperties = properties.get(srcTextureProperties.__renderTarget);
                const dstRenderTargetProperties = properties.get(dstTextureProperties.__renderTarget);
                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, srcRenderTargetProperties.__webglFramebuffer);
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, dstRenderTargetProperties.__webglFramebuffer);
                for(let i = 0; i < depth; i++){
                    // if the source or destination are a 3d target then a layer needs to be bound
                    if (isSrc3D) {
                        _gl.framebufferTextureLayer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, properties.get(srcTexture).__webglTexture, srcLevel, minZ + i);
                        _gl.framebufferTextureLayer(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, properties.get(dstTexture).__webglTexture, dstLevel, dstZ + i);
                    }
                    _gl.blitFramebuffer(minX, minY, width, height, dstX, dstY, width, height, _gl.DEPTH_BUFFER_BIT, _gl.NEAREST);
                }
                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null);
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null);
            } else if (srcLevel !== 0 || srcTexture.isRenderTargetTexture || properties.has(srcTexture)) {
                // get the appropriate frame buffers
                const srcTextureProperties = properties.get(srcTexture);
                const dstTextureProperties = properties.get(dstTexture);
                // bind the frame buffer targets
                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, _srcFramebuffer);
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, _dstFramebuffer);
                for(let i = 0; i < depth; i++){
                    // assign the correct layers and mip maps to the frame buffers
                    if (isSrc3D) _gl.framebufferTextureLayer(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, srcTextureProperties.__webglTexture, srcLevel, minZ + i);
                    else _gl.framebufferTexture2D(_gl.READ_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, srcTextureProperties.__webglTexture, srcLevel);
                    if (isDst3D) _gl.framebufferTextureLayer(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, dstTextureProperties.__webglTexture, dstLevel, dstZ + i);
                    else _gl.framebufferTexture2D(_gl.DRAW_FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D, dstTextureProperties.__webglTexture, dstLevel);
                    // copy the data using the fastest function that can achieve the copy
                    if (srcLevel !== 0) _gl.blitFramebuffer(minX, minY, width, height, dstX, dstY, width, height, _gl.COLOR_BUFFER_BIT, _gl.NEAREST);
                    else if (isDst3D) _gl.copyTexSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ + i, minX, minY, width, height);
                    else _gl.copyTexSubImage2D(glTarget, dstLevel, dstX, dstY, minX, minY, width, height);
                }
                // unbind read, draw buffers
                state.bindFramebuffer(_gl.READ_FRAMEBUFFER, null);
                state.bindFramebuffer(_gl.DRAW_FRAMEBUFFER, null);
            } else if (isDst3D) {
                // copy data into the 3d texture
                if (srcTexture.isDataTexture || srcTexture.isData3DTexture) _gl.texSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, glFormat, glType, image.data);
                else if (dstTexture.isCompressedArrayTexture) _gl.compressedTexSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, glFormat, image.data);
                else _gl.texSubImage3D(glTarget, dstLevel, dstX, dstY, dstZ, width, height, depth, glFormat, glType, image);
            } else {
                // copy data into the 2d texture
                if (srcTexture.isDataTexture) _gl.texSubImage2D(_gl.TEXTURE_2D, dstLevel, dstX, dstY, width, height, glFormat, glType, image.data);
                else if (srcTexture.isCompressedTexture) _gl.compressedTexSubImage2D(_gl.TEXTURE_2D, dstLevel, dstX, dstY, image.width, image.height, glFormat, image.data);
                else _gl.texSubImage2D(_gl.TEXTURE_2D, dstLevel, dstX, dstY, width, height, glFormat, glType, image);
            }
            // reset values
            _gl.pixelStorei(_gl.UNPACK_ROW_LENGTH, currentUnpackRowLen);
            _gl.pixelStorei(_gl.UNPACK_IMAGE_HEIGHT, currentUnpackImageHeight);
            _gl.pixelStorei(_gl.UNPACK_SKIP_PIXELS, currentUnpackSkipPixels);
            _gl.pixelStorei(_gl.UNPACK_SKIP_ROWS, currentUnpackSkipRows);
            _gl.pixelStorei(_gl.UNPACK_SKIP_IMAGES, currentUnpackSkipImages);
            // Generate mipmaps only when copying level 0
            if (dstLevel === 0 && dstTexture.generateMipmaps) _gl.generateMipmap(glTarget);
            state.unbindTexture();
        };
        this.copyTextureToTexture3D = function(srcTexture, dstTexture, srcRegion = null, dstPosition = null, level = 0) {
            // support previous signature with source box first
            if (srcTexture.isTexture !== true) {
                // @deprecated, r165
                (0, $d5b85d29c0b78636$export$5b28268982f175ba)('WebGLRenderer: copyTextureToTexture3D function signature has changed.');
                srcRegion = arguments[0] || null;
                dstPosition = arguments[1] || null;
                srcTexture = arguments[2];
                dstTexture = arguments[3];
                level = arguments[4] || 0;
            }
            // @deprecated, r170
            (0, $d5b85d29c0b78636$export$5b28268982f175ba)('WebGLRenderer: copyTextureToTexture3D function has been deprecated. Use "copyTextureToTexture" instead.');
            return this.copyTextureToTexture(srcTexture, dstTexture, srcRegion, dstPosition, level);
        };
        this.initRenderTarget = function(target) {
            if (properties.get(target).__webglFramebuffer === undefined) textures.setupRenderTarget(target);
        };
        this.initTexture = function(texture) {
            if (texture.isCubeTexture) textures.setTextureCube(texture, 0);
            else if (texture.isData3DTexture) textures.setTexture3D(texture, 0);
            else if (texture.isDataArrayTexture || texture.isCompressedArrayTexture) textures.setTexture2DArray(texture, 0);
            else textures.setTexture2D(texture, 0);
            state.unbindTexture();
        };
        this.resetState = function() {
            _currentActiveCubeFace = 0;
            _currentActiveMipmapLevel = 0;
            _currentRenderTarget = null;
            state.reset();
            bindingStates.reset();
        };
        if (typeof __THREE_DEVTOOLS__ !== 'undefined') __THREE_DEVTOOLS__.dispatchEvent(new CustomEvent('observe', {
            detail: this
        }));
    }
    get coordinateSystem() {
        return 0, $d5b85d29c0b78636$export$5a0e9190d10875d3;
    }
    get outputColorSpace() {
        return this._outputColorSpace;
    }
    set outputColorSpace(colorSpace) {
        this._outputColorSpace = colorSpace;
        const gl = this.getContext();
        gl.drawingBufferColorspace = (0, $d5b85d29c0b78636$export$5e6fd513f44698c)._getDrawingBufferColorSpace(colorSpace);
        gl.unpackColorSpace = (0, $d5b85d29c0b78636$export$5e6fd513f44698c)._getUnpackColorSpace();
    }
}


var $19eaca503e9293fb$exports = {};
/*! Tweakpane 3.1.10 (c) 2016 cocopon, licensed under the MIT license. */ (function(global, factory) {
    factory($19eaca503e9293fb$exports);
})($19eaca503e9293fb$exports, function(exports1) {
    'use strict';
    /***
     * A simple semantic versioning perser.
     */ class Semver {
        /**
         * @hidden
         */ constructor(text){
            const [core, prerelease] = text.split('-');
            const coreComps = core.split('.');
            this.major = parseInt(coreComps[0], 10);
            this.minor = parseInt(coreComps[1], 10);
            this.patch = parseInt(coreComps[2], 10);
            this.prerelease = prerelease !== null && prerelease !== void 0 ? prerelease : null;
        }
        toString() {
            const core = [
                this.major,
                this.minor,
                this.patch
            ].join('.');
            return this.prerelease !== null ? [
                core,
                this.prerelease
            ].join('-') : core;
        }
    }
    class BladeApi {
        constructor(controller){
            this.controller_ = controller;
        }
        get element() {
            return this.controller_.view.element;
        }
        get disabled() {
            return this.controller_.viewProps.get('disabled');
        }
        set disabled(disabled) {
            this.controller_.viewProps.set('disabled', disabled);
        }
        get hidden() {
            return this.controller_.viewProps.get('hidden');
        }
        set hidden(hidden) {
            this.controller_.viewProps.set('hidden', hidden);
        }
        dispose() {
            this.controller_.viewProps.set('disposed', true);
        }
    }
    class TpEvent {
        constructor(target){
            this.target = target;
        }
    }
    class TpChangeEvent extends TpEvent {
        constructor(target, value, presetKey, last){
            super(target);
            this.value = value;
            this.presetKey = presetKey;
            this.last = last !== null && last !== void 0 ? last : true;
        }
    }
    class TpUpdateEvent extends TpEvent {
        constructor(target, value, presetKey){
            super(target);
            this.value = value;
            this.presetKey = presetKey;
        }
    }
    class TpFoldEvent extends TpEvent {
        constructor(target, expanded){
            super(target);
            this.expanded = expanded;
        }
    }
    class TpTabSelectEvent extends TpEvent {
        constructor(target, index){
            super(target);
            this.index = index;
        }
    }
    function forceCast(v) {
        return v;
    }
    function isEmpty(value) {
        return value === null || value === undefined;
    }
    function deepEqualsArray(a1, a2) {
        if (a1.length !== a2.length) return false;
        for(let i = 0; i < a1.length; i++){
            if (a1[i] !== a2[i]) return false;
        }
        return true;
    }
    function isPropertyWritable(obj, key) {
        let target = obj;
        do {
            const d = Object.getOwnPropertyDescriptor(target, key);
            if (d && (d.set !== undefined || d.writable === true)) return true;
            target = Object.getPrototypeOf(target);
        }while (target !== null);
        return false;
    }
    const CREATE_MESSAGE_MAP = {
        alreadydisposed: ()=>'View has been already disposed',
        invalidparams: (context)=>`Invalid parameters for '${context.name}'`,
        nomatchingcontroller: (context)=>`No matching controller for '${context.key}'`,
        nomatchingview: (context)=>`No matching view for '${JSON.stringify(context.params)}'`,
        notbindable: ()=>`Value is not bindable`,
        propertynotfound: (context)=>`Property '${context.name}' not found`,
        shouldneverhappen: ()=>'This error should never happen'
    };
    class TpError {
        static alreadyDisposed() {
            return new TpError({
                type: 'alreadydisposed'
            });
        }
        static notBindable() {
            return new TpError({
                type: 'notbindable'
            });
        }
        static propertyNotFound(name) {
            return new TpError({
                type: 'propertynotfound',
                context: {
                    name: name
                }
            });
        }
        static shouldNeverHappen() {
            return new TpError({
                type: 'shouldneverhappen'
            });
        }
        constructor(config){
            var _a;
            this.message = (_a = CREATE_MESSAGE_MAP[config.type](forceCast(config.context))) !== null && _a !== void 0 ? _a : 'Unexpected error';
            this.name = this.constructor.name;
            this.stack = new Error(this.message).stack;
            this.type = config.type;
        }
    }
    class BindingTarget {
        constructor(obj, key, opt_id){
            this.obj_ = obj;
            this.key_ = key;
            this.presetKey_ = opt_id !== null && opt_id !== void 0 ? opt_id : key;
        }
        static isBindable(obj) {
            if (obj === null) return false;
            if (typeof obj !== 'object' && typeof obj !== 'function') return false;
            return true;
        }
        get key() {
            return this.key_;
        }
        get presetKey() {
            return this.presetKey_;
        }
        read() {
            return this.obj_[this.key_];
        }
        write(value) {
            this.obj_[this.key_] = value;
        }
        writeProperty(name, value) {
            const valueObj = this.read();
            if (!BindingTarget.isBindable(valueObj)) throw TpError.notBindable();
            if (!(name in valueObj)) throw TpError.propertyNotFound(name);
            valueObj[name] = value;
        }
    }
    class ButtonApi extends BladeApi {
        get label() {
            return this.controller_.props.get('label');
        }
        set label(label) {
            this.controller_.props.set('label', label);
        }
        get title() {
            var _a;
            return (_a = this.controller_.valueController.props.get('title')) !== null && _a !== void 0 ? _a : '';
        }
        set title(title) {
            this.controller_.valueController.props.set('title', title);
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            const emitter = this.controller_.valueController.emitter;
            emitter.on(eventName, ()=>{
                bh(new TpEvent(this));
            });
            return this;
        }
    }
    class Emitter {
        constructor(){
            this.observers_ = {};
        }
        on(eventName, handler) {
            let observers = this.observers_[eventName];
            if (!observers) observers = this.observers_[eventName] = [];
            observers.push({
                handler: handler
            });
            return this;
        }
        off(eventName, handler) {
            const observers = this.observers_[eventName];
            if (observers) this.observers_[eventName] = observers.filter((observer)=>{
                return observer.handler !== handler;
            });
            return this;
        }
        emit(eventName, event) {
            const observers = this.observers_[eventName];
            if (!observers) return;
            observers.forEach((observer)=>{
                observer.handler(event);
            });
        }
    }
    const PREFIX = 'tp';
    function ClassName(viewName) {
        const fn = (opt_elementName, opt_modifier)=>{
            return [
                PREFIX,
                '-',
                viewName,
                'v',
                opt_elementName ? `_${opt_elementName}` : '',
                opt_modifier ? `-${opt_modifier}` : ''
            ].join('');
        };
        return fn;
    }
    function compose(h1, h2) {
        return (input)=>h2(h1(input));
    }
    function extractValue(ev) {
        return ev.rawValue;
    }
    function bindValue(value, applyValue) {
        value.emitter.on('change', compose(extractValue, applyValue));
        applyValue(value.rawValue);
    }
    function bindValueMap(valueMap, key, applyValue) {
        bindValue(valueMap.value(key), applyValue);
    }
    function applyClass(elem, className, active) {
        if (active) elem.classList.add(className);
        else elem.classList.remove(className);
    }
    function valueToClassName(elem, className) {
        return (value)=>{
            applyClass(elem, className, value);
        };
    }
    function bindValueToTextContent(value, elem) {
        bindValue(value, (text)=>{
            elem.textContent = text !== null && text !== void 0 ? text : '';
        });
    }
    const className$q = ClassName('btn');
    class ButtonView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$q());
            config.viewProps.bindClassModifiers(this.element);
            const buttonElem = doc.createElement('button');
            buttonElem.classList.add(className$q('b'));
            config.viewProps.bindDisabled(buttonElem);
            this.element.appendChild(buttonElem);
            this.buttonElement = buttonElem;
            const titleElem = doc.createElement('div');
            titleElem.classList.add(className$q('t'));
            bindValueToTextContent(config.props.value('title'), titleElem);
            this.buttonElement.appendChild(titleElem);
        }
    }
    class ButtonController {
        constructor(doc, config){
            this.emitter = new Emitter();
            this.onClick_ = this.onClick_.bind(this);
            this.props = config.props;
            this.viewProps = config.viewProps;
            this.view = new ButtonView(doc, {
                props: this.props,
                viewProps: this.viewProps
            });
            this.view.buttonElement.addEventListener('click', this.onClick_);
        }
        onClick_() {
            this.emitter.emit('click', {
                sender: this
            });
        }
    }
    class BoundValue {
        constructor(initialValue, config){
            var _a;
            this.constraint_ = config === null || config === void 0 ? void 0 : config.constraint;
            this.equals_ = (_a = config === null || config === void 0 ? void 0 : config.equals) !== null && _a !== void 0 ? _a : (v1, v2)=>v1 === v2;
            this.emitter = new Emitter();
            this.rawValue_ = initialValue;
        }
        get constraint() {
            return this.constraint_;
        }
        get rawValue() {
            return this.rawValue_;
        }
        set rawValue(rawValue) {
            this.setRawValue(rawValue, {
                forceEmit: false,
                last: true
            });
        }
        setRawValue(rawValue, options) {
            const opts = options !== null && options !== void 0 ? options : {
                forceEmit: false,
                last: true
            };
            const constrainedValue = this.constraint_ ? this.constraint_.constrain(rawValue) : rawValue;
            const prevValue = this.rawValue_;
            const changed = !this.equals_(prevValue, constrainedValue);
            if (!changed && !opts.forceEmit) return;
            this.emitter.emit('beforechange', {
                sender: this
            });
            this.rawValue_ = constrainedValue;
            this.emitter.emit('change', {
                options: opts,
                previousRawValue: prevValue,
                rawValue: constrainedValue,
                sender: this
            });
        }
    }
    class PrimitiveValue {
        constructor(initialValue){
            this.emitter = new Emitter();
            this.value_ = initialValue;
        }
        get rawValue() {
            return this.value_;
        }
        set rawValue(value) {
            this.setRawValue(value, {
                forceEmit: false,
                last: true
            });
        }
        setRawValue(value, options) {
            const opts = options !== null && options !== void 0 ? options : {
                forceEmit: false,
                last: true
            };
            const prevValue = this.value_;
            if (prevValue === value && !opts.forceEmit) return;
            this.emitter.emit('beforechange', {
                sender: this
            });
            this.value_ = value;
            this.emitter.emit('change', {
                options: opts,
                previousRawValue: prevValue,
                rawValue: this.value_,
                sender: this
            });
        }
    }
    function createValue(initialValue, config) {
        const constraint = config === null || config === void 0 ? void 0 : config.constraint;
        const equals = config === null || config === void 0 ? void 0 : config.equals;
        if (!constraint && !equals) return new PrimitiveValue(initialValue);
        return new BoundValue(initialValue, config);
    }
    class ValueMap {
        constructor(valueMap){
            this.emitter = new Emitter();
            this.valMap_ = valueMap;
            for(const key in this.valMap_){
                const v = this.valMap_[key];
                v.emitter.on('change', ()=>{
                    this.emitter.emit('change', {
                        key: key,
                        sender: this
                    });
                });
            }
        }
        static createCore(initialValue) {
            const keys = Object.keys(initialValue);
            return keys.reduce((o, key)=>{
                return Object.assign(o, {
                    [key]: createValue(initialValue[key])
                });
            }, {});
        }
        static fromObject(initialValue) {
            const core = this.createCore(initialValue);
            return new ValueMap(core);
        }
        get(key) {
            return this.valMap_[key].rawValue;
        }
        set(key, value) {
            this.valMap_[key].rawValue = value;
        }
        value(key) {
            return this.valMap_[key];
        }
    }
    function parseObject(value, keyToParserMap) {
        const keys = Object.keys(keyToParserMap);
        const result = keys.reduce((tmp, key)=>{
            if (tmp === undefined) return undefined;
            const parser = keyToParserMap[key];
            const result = parser(value[key]);
            return result.succeeded ? Object.assign(Object.assign({}, tmp), {
                [key]: result.value
            }) : undefined;
        }, {});
        return forceCast(result);
    }
    function parseArray(value, parseItem) {
        return value.reduce((tmp, item)=>{
            if (tmp === undefined) return undefined;
            const result = parseItem(item);
            if (!result.succeeded || result.value === undefined) return undefined;
            return [
                ...tmp,
                result.value
            ];
        }, []);
    }
    function isObject(value) {
        if (value === null) return false;
        return typeof value === 'object';
    }
    function createParamsParserBuilder(parse) {
        return (optional)=>(v)=>{
                if (!optional && v === undefined) return {
                    succeeded: false,
                    value: undefined
                };
                if (optional && v === undefined) return {
                    succeeded: true,
                    value: undefined
                };
                const result = parse(v);
                return result !== undefined ? {
                    succeeded: true,
                    value: result
                } : {
                    succeeded: false,
                    value: undefined
                };
            };
    }
    function createParamsParserBuilders(optional) {
        return {
            custom: (parse)=>createParamsParserBuilder(parse)(optional),
            boolean: createParamsParserBuilder((v)=>typeof v === 'boolean' ? v : undefined)(optional),
            number: createParamsParserBuilder((v)=>typeof v === 'number' ? v : undefined)(optional),
            string: createParamsParserBuilder((v)=>typeof v === 'string' ? v : undefined)(optional),
            function: createParamsParserBuilder((v)=>typeof v === 'function' ? v : undefined)(optional),
            constant: (value)=>createParamsParserBuilder((v)=>v === value ? value : undefined)(optional),
            raw: createParamsParserBuilder((v)=>v)(optional),
            object: (keyToParserMap)=>createParamsParserBuilder((v)=>{
                    if (!isObject(v)) return undefined;
                    return parseObject(v, keyToParserMap);
                })(optional),
            array: (itemParser)=>createParamsParserBuilder((v)=>{
                    if (!Array.isArray(v)) return undefined;
                    return parseArray(v, itemParser);
                })(optional)
        };
    }
    const ParamsParsers = {
        optional: createParamsParserBuilders(true),
        required: createParamsParserBuilders(false)
    };
    function parseParams(value, keyToParserMap) {
        const result = ParamsParsers.required.object(keyToParserMap)(value);
        return result.succeeded ? result.value : undefined;
    }
    function warnMissing(info) {
        console.warn([
            `Missing '${info.key}' of ${info.target} in ${info.place}.`,
            'Please rebuild plugins with the latest core package.'
        ].join(' '));
    }
    function disposeElement(elem) {
        if (elem && elem.parentElement) elem.parentElement.removeChild(elem);
        return null;
    }
    class ReadonlyValue {
        constructor(value){
            this.value_ = value;
        }
        static create(value) {
            return [
                new ReadonlyValue(value),
                (rawValue, options)=>{
                    value.setRawValue(rawValue, options);
                }
            ];
        }
        get emitter() {
            return this.value_.emitter;
        }
        get rawValue() {
            return this.value_.rawValue;
        }
    }
    const className$p = ClassName('');
    function valueToModifier(elem, modifier) {
        return valueToClassName(elem, className$p(undefined, modifier));
    }
    class ViewProps extends ValueMap {
        constructor(valueMap){
            var _a;
            super(valueMap);
            this.onDisabledChange_ = this.onDisabledChange_.bind(this);
            this.onParentChange_ = this.onParentChange_.bind(this);
            this.onParentGlobalDisabledChange_ = this.onParentGlobalDisabledChange_.bind(this);
            [this.globalDisabled_, this.setGlobalDisabled_] = ReadonlyValue.create(createValue(this.getGlobalDisabled_()));
            this.value('disabled').emitter.on('change', this.onDisabledChange_);
            this.value('parent').emitter.on('change', this.onParentChange_);
            (_a = this.get('parent')) === null || _a === void 0 || _a.globalDisabled.emitter.on('change', this.onParentGlobalDisabledChange_);
        }
        static create(opt_initialValue) {
            var _a, _b, _c;
            const initialValue = opt_initialValue !== null && opt_initialValue !== void 0 ? opt_initialValue : {};
            return new ViewProps(ValueMap.createCore({
                disabled: (_a = initialValue.disabled) !== null && _a !== void 0 ? _a : false,
                disposed: false,
                hidden: (_b = initialValue.hidden) !== null && _b !== void 0 ? _b : false,
                parent: (_c = initialValue.parent) !== null && _c !== void 0 ? _c : null
            }));
        }
        get globalDisabled() {
            return this.globalDisabled_;
        }
        bindClassModifiers(elem) {
            bindValue(this.globalDisabled_, valueToModifier(elem, 'disabled'));
            bindValueMap(this, 'hidden', valueToModifier(elem, 'hidden'));
        }
        bindDisabled(target) {
            bindValue(this.globalDisabled_, (disabled)=>{
                target.disabled = disabled;
            });
        }
        bindTabIndex(elem) {
            bindValue(this.globalDisabled_, (disabled)=>{
                elem.tabIndex = disabled ? -1 : 0;
            });
        }
        handleDispose(callback) {
            this.value('disposed').emitter.on('change', (disposed)=>{
                if (disposed) callback();
            });
        }
        getGlobalDisabled_() {
            const parent = this.get('parent');
            const parentDisabled = parent ? parent.globalDisabled.rawValue : false;
            return parentDisabled || this.get('disabled');
        }
        updateGlobalDisabled_() {
            this.setGlobalDisabled_(this.getGlobalDisabled_());
        }
        onDisabledChange_() {
            this.updateGlobalDisabled_();
        }
        onParentGlobalDisabledChange_() {
            this.updateGlobalDisabled_();
        }
        onParentChange_(ev) {
            var _a;
            const prevParent = ev.previousRawValue;
            prevParent === null || prevParent === void 0 || prevParent.globalDisabled.emitter.off('change', this.onParentGlobalDisabledChange_);
            (_a = this.get('parent')) === null || _a === void 0 || _a.globalDisabled.emitter.on('change', this.onParentGlobalDisabledChange_);
            this.updateGlobalDisabled_();
        }
    }
    function getAllBladePositions() {
        return [
            'veryfirst',
            'first',
            'last',
            'verylast'
        ];
    }
    const className$o = ClassName('');
    const POS_TO_CLASS_NAME_MAP = {
        veryfirst: 'vfst',
        first: 'fst',
        last: 'lst',
        verylast: 'vlst'
    };
    class BladeController {
        constructor(config){
            this.parent_ = null;
            this.blade = config.blade;
            this.view = config.view;
            this.viewProps = config.viewProps;
            const elem = this.view.element;
            this.blade.value('positions').emitter.on('change', ()=>{
                getAllBladePositions().forEach((pos)=>{
                    elem.classList.remove(className$o(undefined, POS_TO_CLASS_NAME_MAP[pos]));
                });
                this.blade.get('positions').forEach((pos)=>{
                    elem.classList.add(className$o(undefined, POS_TO_CLASS_NAME_MAP[pos]));
                });
            });
            this.viewProps.handleDispose(()=>{
                disposeElement(elem);
            });
        }
        get parent() {
            return this.parent_;
        }
        set parent(parent) {
            this.parent_ = parent;
            if (!('parent' in this.viewProps.valMap_)) {
                warnMissing({
                    key: 'parent',
                    target: ViewProps.name,
                    place: 'BladeController.parent'
                });
                return;
            }
            this.viewProps.set('parent', this.parent_ ? this.parent_.viewProps : null);
        }
    }
    const SVG_NS = 'http://www.w3.org/2000/svg';
    function forceReflow(element) {
        element.offsetHeight;
    }
    function disableTransitionTemporarily(element, callback) {
        const t = element.style.transition;
        element.style.transition = 'none';
        callback();
        element.style.transition = t;
    }
    function supportsTouch(doc) {
        return doc.ontouchstart !== undefined;
    }
    function getGlobalObject() {
        return globalThis;
    }
    function getWindowDocument() {
        const globalObj = forceCast(getGlobalObject());
        return globalObj.document;
    }
    function getCanvasContext(canvasElement) {
        const win = canvasElement.ownerDocument.defaultView;
        if (!win) return null;
        const isBrowser = 'document' in win;
        return isBrowser ? canvasElement.getContext('2d', {
            willReadFrequently: true
        }) : null;
    }
    const ICON_ID_TO_INNER_HTML_MAP = {
        check: '<path d="M2 8l4 4l8 -8"/>',
        dropdown: '<path d="M5 7h6l-3 3 z"/>',
        p2dpad: '<path d="M8 4v8"/><path d="M4 8h8"/><circle cx="12" cy="12" r="1.2"/>'
    };
    function createSvgIconElement(document, iconId) {
        const elem = document.createElementNS(SVG_NS, 'svg');
        elem.innerHTML = ICON_ID_TO_INNER_HTML_MAP[iconId];
        return elem;
    }
    function insertElementAt(parentElement, element, index) {
        parentElement.insertBefore(element, parentElement.children[index]);
    }
    function removeElement(element) {
        if (element.parentElement) element.parentElement.removeChild(element);
    }
    function removeChildElements(element) {
        while(element.children.length > 0)element.removeChild(element.children[0]);
    }
    function removeChildNodes(element) {
        while(element.childNodes.length > 0)element.removeChild(element.childNodes[0]);
    }
    function findNextTarget(ev) {
        if (ev.relatedTarget) return forceCast(ev.relatedTarget);
        if ('explicitOriginalTarget' in ev) return ev.explicitOriginalTarget;
        return null;
    }
    const className$n = ClassName('lbl');
    function createLabelNode(doc, label) {
        const frag = doc.createDocumentFragment();
        const lineNodes = label.split('\n').map((line)=>{
            return doc.createTextNode(line);
        });
        lineNodes.forEach((lineNode, index)=>{
            if (index > 0) frag.appendChild(doc.createElement('br'));
            frag.appendChild(lineNode);
        });
        return frag;
    }
    class LabelView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$n());
            config.viewProps.bindClassModifiers(this.element);
            const labelElem = doc.createElement('div');
            labelElem.classList.add(className$n('l'));
            bindValueMap(config.props, 'label', (value)=>{
                if (isEmpty(value)) this.element.classList.add(className$n(undefined, 'nol'));
                else {
                    this.element.classList.remove(className$n(undefined, 'nol'));
                    removeChildNodes(labelElem);
                    labelElem.appendChild(createLabelNode(doc, value));
                }
            });
            this.element.appendChild(labelElem);
            this.labelElement = labelElem;
            const valueElem = doc.createElement('div');
            valueElem.classList.add(className$n('v'));
            this.element.appendChild(valueElem);
            this.valueElement = valueElem;
        }
    }
    class LabelController extends BladeController {
        constructor(doc, config){
            const viewProps = config.valueController.viewProps;
            super(Object.assign(Object.assign({}, config), {
                view: new LabelView(doc, {
                    props: config.props,
                    viewProps: viewProps
                }),
                viewProps: viewProps
            }));
            this.props = config.props;
            this.valueController = config.valueController;
            this.view.valueElement.appendChild(this.valueController.view.element);
        }
    }
    const ButtonBladePlugin = {
        id: 'button',
        type: 'blade',
        accept (params) {
            const p = ParamsParsers;
            const result = parseParams(params, {
                title: p.required.string,
                view: p.required.constant('button'),
                label: p.optional.string
            });
            return result ? {
                params: result
            } : null;
        },
        controller (args) {
            return new LabelController(args.document, {
                blade: args.blade,
                props: ValueMap.fromObject({
                    label: args.params.label
                }),
                valueController: new ButtonController(args.document, {
                    props: ValueMap.fromObject({
                        title: args.params.title
                    }),
                    viewProps: args.viewProps
                })
            });
        },
        api (args) {
            if (!(args.controller instanceof LabelController)) return null;
            if (!(args.controller.valueController instanceof ButtonController)) return null;
            return new ButtonApi(args.controller);
        }
    };
    class ValueBladeController extends BladeController {
        constructor(config){
            super(config);
            this.value = config.value;
        }
    }
    function createBlade() {
        return new ValueMap({
            positions: createValue([], {
                equals: deepEqualsArray
            })
        });
    }
    class Foldable extends ValueMap {
        constructor(valueMap){
            super(valueMap);
        }
        static create(expanded) {
            const coreObj = {
                completed: true,
                expanded: expanded,
                expandedHeight: null,
                shouldFixHeight: false,
                temporaryExpanded: null
            };
            const core = ValueMap.createCore(coreObj);
            return new Foldable(core);
        }
        get styleExpanded() {
            var _a;
            return (_a = this.get('temporaryExpanded')) !== null && _a !== void 0 ? _a : this.get('expanded');
        }
        get styleHeight() {
            if (!this.styleExpanded) return '0';
            const exHeight = this.get('expandedHeight');
            if (this.get('shouldFixHeight') && !isEmpty(exHeight)) return `${exHeight}px`;
            return 'auto';
        }
        bindExpandedClass(elem, expandedClassName) {
            const onExpand = ()=>{
                const expanded = this.styleExpanded;
                if (expanded) elem.classList.add(expandedClassName);
                else elem.classList.remove(expandedClassName);
            };
            bindValueMap(this, 'expanded', onExpand);
            bindValueMap(this, 'temporaryExpanded', onExpand);
        }
        cleanUpTransition() {
            this.set('shouldFixHeight', false);
            this.set('expandedHeight', null);
            this.set('completed', true);
        }
    }
    function computeExpandedFolderHeight(folder, containerElement) {
        let height = 0;
        disableTransitionTemporarily(containerElement, ()=>{
            folder.set('expandedHeight', null);
            folder.set('temporaryExpanded', true);
            forceReflow(containerElement);
            height = containerElement.clientHeight;
            folder.set('temporaryExpanded', null);
            forceReflow(containerElement);
        });
        return height;
    }
    function applyHeight(foldable, elem) {
        elem.style.height = foldable.styleHeight;
    }
    function bindFoldable(foldable, elem) {
        foldable.value('expanded').emitter.on('beforechange', ()=>{
            foldable.set('completed', false);
            if (isEmpty(foldable.get('expandedHeight'))) {
                const h = computeExpandedFolderHeight(foldable, elem);
                if (h > 0) foldable.set('expandedHeight', h);
            }
            foldable.set('shouldFixHeight', true);
            forceReflow(elem);
        });
        foldable.emitter.on('change', ()=>{
            applyHeight(foldable, elem);
        });
        applyHeight(foldable, elem);
        elem.addEventListener('transitionend', (ev)=>{
            if (ev.propertyName !== 'height') return;
            foldable.cleanUpTransition();
        });
    }
    class RackLikeApi extends BladeApi {
        constructor(controller, rackApi){
            super(controller);
            this.rackApi_ = rackApi;
        }
    }
    function addButtonAsBlade(api, params) {
        return api.addBlade(Object.assign(Object.assign({}, params), {
            view: 'button'
        }));
    }
    function addFolderAsBlade(api, params) {
        return api.addBlade(Object.assign(Object.assign({}, params), {
            view: 'folder'
        }));
    }
    function addSeparatorAsBlade(api, opt_params) {
        const params = opt_params !== null && opt_params !== void 0 ? opt_params : {};
        return api.addBlade(Object.assign(Object.assign({}, params), {
            view: 'separator'
        }));
    }
    function addTabAsBlade(api, params) {
        return api.addBlade(Object.assign(Object.assign({}, params), {
            view: 'tab'
        }));
    }
    class NestedOrderedSet {
        constructor(extract){
            this.emitter = new Emitter();
            this.items_ = [];
            this.cache_ = new Set();
            this.onSubListAdd_ = this.onSubListAdd_.bind(this);
            this.onSubListRemove_ = this.onSubListRemove_.bind(this);
            this.extract_ = extract;
        }
        get items() {
            return this.items_;
        }
        allItems() {
            return Array.from(this.cache_);
        }
        find(callback) {
            for (const item of this.allItems()){
                if (callback(item)) return item;
            }
            return null;
        }
        includes(item) {
            return this.cache_.has(item);
        }
        add(item, opt_index) {
            if (this.includes(item)) throw TpError.shouldNeverHappen();
            const index = opt_index !== undefined ? opt_index : this.items_.length;
            this.items_.splice(index, 0, item);
            this.cache_.add(item);
            const subList = this.extract_(item);
            if (subList) {
                subList.emitter.on('add', this.onSubListAdd_);
                subList.emitter.on('remove', this.onSubListRemove_);
                subList.allItems().forEach((item)=>{
                    this.cache_.add(item);
                });
            }
            this.emitter.emit('add', {
                index: index,
                item: item,
                root: this,
                target: this
            });
        }
        remove(item) {
            const index = this.items_.indexOf(item);
            if (index < 0) return;
            this.items_.splice(index, 1);
            this.cache_.delete(item);
            const subList = this.extract_(item);
            if (subList) {
                subList.emitter.off('add', this.onSubListAdd_);
                subList.emitter.off('remove', this.onSubListRemove_);
            }
            this.emitter.emit('remove', {
                index: index,
                item: item,
                root: this,
                target: this
            });
        }
        onSubListAdd_(ev) {
            this.cache_.add(ev.item);
            this.emitter.emit('add', {
                index: ev.index,
                item: ev.item,
                root: this,
                target: ev.target
            });
        }
        onSubListRemove_(ev) {
            this.cache_.delete(ev.item);
            this.emitter.emit('remove', {
                index: ev.index,
                item: ev.item,
                root: this,
                target: ev.target
            });
        }
    }
    class InputBindingApi extends BladeApi {
        constructor(controller){
            super(controller);
            this.onBindingChange_ = this.onBindingChange_.bind(this);
            this.emitter_ = new Emitter();
            this.controller_.binding.emitter.on('change', this.onBindingChange_);
        }
        get label() {
            return this.controller_.props.get('label');
        }
        set label(label) {
            this.controller_.props.set('label', label);
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
        refresh() {
            this.controller_.binding.read();
        }
        onBindingChange_(ev) {
            const value = ev.sender.target.read();
            this.emitter_.emit('change', {
                event: new TpChangeEvent(this, forceCast(value), this.controller_.binding.target.presetKey, ev.options.last)
            });
        }
    }
    class InputBindingController extends LabelController {
        constructor(doc, config){
            super(doc, config);
            this.binding = config.binding;
        }
    }
    class MonitorBindingApi extends BladeApi {
        constructor(controller){
            super(controller);
            this.onBindingUpdate_ = this.onBindingUpdate_.bind(this);
            this.emitter_ = new Emitter();
            this.controller_.binding.emitter.on('update', this.onBindingUpdate_);
        }
        get label() {
            return this.controller_.props.get('label');
        }
        set label(label) {
            this.controller_.props.set('label', label);
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
        refresh() {
            this.controller_.binding.read();
        }
        onBindingUpdate_(ev) {
            const value = ev.sender.target.read();
            this.emitter_.emit('update', {
                event: new TpUpdateEvent(this, forceCast(value), this.controller_.binding.target.presetKey)
            });
        }
    }
    class MonitorBindingController extends LabelController {
        constructor(doc, config){
            super(doc, config);
            this.binding = config.binding;
            this.viewProps.bindDisabled(this.binding.ticker);
            this.viewProps.handleDispose(()=>{
                this.binding.dispose();
            });
        }
    }
    function findSubBladeApiSet(api) {
        if (api instanceof RackApi) return api['apiSet_'];
        if (api instanceof RackLikeApi) return api['rackApi_']['apiSet_'];
        return null;
    }
    function getApiByController(apiSet, controller) {
        const api = apiSet.find((api)=>api.controller_ === controller);
        if (!api) throw TpError.shouldNeverHappen();
        return api;
    }
    function createBindingTarget(obj, key, opt_id) {
        if (!BindingTarget.isBindable(obj)) throw TpError.notBindable();
        return new BindingTarget(obj, key, opt_id);
    }
    class RackApi extends BladeApi {
        constructor(controller, pool){
            super(controller);
            this.onRackAdd_ = this.onRackAdd_.bind(this);
            this.onRackRemove_ = this.onRackRemove_.bind(this);
            this.onRackInputChange_ = this.onRackInputChange_.bind(this);
            this.onRackMonitorUpdate_ = this.onRackMonitorUpdate_.bind(this);
            this.emitter_ = new Emitter();
            this.apiSet_ = new NestedOrderedSet(findSubBladeApiSet);
            this.pool_ = pool;
            const rack = this.controller_.rack;
            rack.emitter.on('add', this.onRackAdd_);
            rack.emitter.on('remove', this.onRackRemove_);
            rack.emitter.on('inputchange', this.onRackInputChange_);
            rack.emitter.on('monitorupdate', this.onRackMonitorUpdate_);
            rack.children.forEach((bc)=>{
                this.setUpApi_(bc);
            });
        }
        get children() {
            return this.controller_.rack.children.map((bc)=>getApiByController(this.apiSet_, bc));
        }
        addInput(object, key, opt_params) {
            const params = opt_params !== null && opt_params !== void 0 ? opt_params : {};
            const doc = this.controller_.view.element.ownerDocument;
            const bc = this.pool_.createInput(doc, createBindingTarget(object, key, params.presetKey), params);
            const api = new InputBindingApi(bc);
            return this.add(api, params.index);
        }
        addMonitor(object, key, opt_params) {
            const params = opt_params !== null && opt_params !== void 0 ? opt_params : {};
            const doc = this.controller_.view.element.ownerDocument;
            const bc = this.pool_.createMonitor(doc, createBindingTarget(object, key), params);
            const api = new MonitorBindingApi(bc);
            return forceCast(this.add(api, params.index));
        }
        addFolder(params) {
            return addFolderAsBlade(this, params);
        }
        addButton(params) {
            return addButtonAsBlade(this, params);
        }
        addSeparator(opt_params) {
            return addSeparatorAsBlade(this, opt_params);
        }
        addTab(params) {
            return addTabAsBlade(this, params);
        }
        add(api, opt_index) {
            this.controller_.rack.add(api.controller_, opt_index);
            const gapi = this.apiSet_.find((a)=>a.controller_ === api.controller_);
            if (gapi) this.apiSet_.remove(gapi);
            this.apiSet_.add(api);
            return api;
        }
        remove(api) {
            this.controller_.rack.remove(api.controller_);
        }
        addBlade(params) {
            const doc = this.controller_.view.element.ownerDocument;
            const bc = this.pool_.createBlade(doc, params);
            const api = this.pool_.createBladeApi(bc);
            return this.add(api, params.index);
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
        setUpApi_(bc) {
            const api = this.apiSet_.find((api)=>api.controller_ === bc);
            if (!api) this.apiSet_.add(this.pool_.createBladeApi(bc));
        }
        onRackAdd_(ev) {
            this.setUpApi_(ev.bladeController);
        }
        onRackRemove_(ev) {
            if (ev.isRoot) {
                const api = getApiByController(this.apiSet_, ev.bladeController);
                this.apiSet_.remove(api);
            }
        }
        onRackInputChange_(ev) {
            const bc = ev.bladeController;
            if (bc instanceof InputBindingController) {
                const api = getApiByController(this.apiSet_, bc);
                const binding = bc.binding;
                this.emitter_.emit('change', {
                    event: new TpChangeEvent(api, forceCast(binding.target.read()), binding.target.presetKey, ev.options.last)
                });
            } else if (bc instanceof ValueBladeController) {
                const api = getApiByController(this.apiSet_, bc);
                this.emitter_.emit('change', {
                    event: new TpChangeEvent(api, bc.value.rawValue, undefined, ev.options.last)
                });
            }
        }
        onRackMonitorUpdate_(ev) {
            if (!(ev.bladeController instanceof MonitorBindingController)) throw TpError.shouldNeverHappen();
            const api = getApiByController(this.apiSet_, ev.bladeController);
            const binding = ev.bladeController.binding;
            this.emitter_.emit('update', {
                event: new TpUpdateEvent(api, forceCast(binding.target.read()), binding.target.presetKey)
            });
        }
    }
    class FolderApi extends RackLikeApi {
        constructor(controller, pool){
            super(controller, new RackApi(controller.rackController, pool));
            this.emitter_ = new Emitter();
            this.controller_.foldable.value('expanded').emitter.on('change', (ev)=>{
                this.emitter_.emit('fold', {
                    event: new TpFoldEvent(this, ev.sender.rawValue)
                });
            });
            this.rackApi_.on('change', (ev)=>{
                this.emitter_.emit('change', {
                    event: ev
                });
            });
            this.rackApi_.on('update', (ev)=>{
                this.emitter_.emit('update', {
                    event: ev
                });
            });
        }
        get expanded() {
            return this.controller_.foldable.get('expanded');
        }
        set expanded(expanded) {
            this.controller_.foldable.set('expanded', expanded);
        }
        get title() {
            return this.controller_.props.get('title');
        }
        set title(title) {
            this.controller_.props.set('title', title);
        }
        get children() {
            return this.rackApi_.children;
        }
        addInput(object, key, opt_params) {
            return this.rackApi_.addInput(object, key, opt_params);
        }
        addMonitor(object, key, opt_params) {
            return this.rackApi_.addMonitor(object, key, opt_params);
        }
        addFolder(params) {
            return this.rackApi_.addFolder(params);
        }
        addButton(params) {
            return this.rackApi_.addButton(params);
        }
        addSeparator(opt_params) {
            return this.rackApi_.addSeparator(opt_params);
        }
        addTab(params) {
            return this.rackApi_.addTab(params);
        }
        add(api, opt_index) {
            return this.rackApi_.add(api, opt_index);
        }
        remove(api) {
            this.rackApi_.remove(api);
        }
        addBlade(params) {
            return this.rackApi_.addBlade(params);
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
    }
    class RackLikeController extends BladeController {
        constructor(config){
            super({
                blade: config.blade,
                view: config.view,
                viewProps: config.rackController.viewProps
            });
            this.rackController = config.rackController;
        }
    }
    class PlainView {
        constructor(doc, config){
            const className = ClassName(config.viewName);
            this.element = doc.createElement('div');
            this.element.classList.add(className());
            config.viewProps.bindClassModifiers(this.element);
        }
    }
    function findInputBindingController(bcs, b) {
        for(let i = 0; i < bcs.length; i++){
            const bc = bcs[i];
            if (bc instanceof InputBindingController && bc.binding === b) return bc;
        }
        return null;
    }
    function findMonitorBindingController(bcs, b) {
        for(let i = 0; i < bcs.length; i++){
            const bc = bcs[i];
            if (bc instanceof MonitorBindingController && bc.binding === b) return bc;
        }
        return null;
    }
    function findValueBladeController(bcs, v) {
        for(let i = 0; i < bcs.length; i++){
            const bc = bcs[i];
            if (bc instanceof ValueBladeController && bc.value === v) return bc;
        }
        return null;
    }
    function findSubRack(bc) {
        if (bc instanceof RackController) return bc.rack;
        if (bc instanceof RackLikeController) return bc.rackController.rack;
        return null;
    }
    function findSubBladeControllerSet(bc) {
        const rack = findSubRack(bc);
        return rack ? rack['bcSet_'] : null;
    }
    class BladeRack {
        constructor(config){
            var _a, _b;
            this.onBladePositionsChange_ = this.onBladePositionsChange_.bind(this);
            this.onSetAdd_ = this.onSetAdd_.bind(this);
            this.onSetRemove_ = this.onSetRemove_.bind(this);
            this.onChildDispose_ = this.onChildDispose_.bind(this);
            this.onChildPositionsChange_ = this.onChildPositionsChange_.bind(this);
            this.onChildInputChange_ = this.onChildInputChange_.bind(this);
            this.onChildMonitorUpdate_ = this.onChildMonitorUpdate_.bind(this);
            this.onChildValueChange_ = this.onChildValueChange_.bind(this);
            this.onChildViewPropsChange_ = this.onChildViewPropsChange_.bind(this);
            this.onDescendantLayout_ = this.onDescendantLayout_.bind(this);
            this.onDescendantInputChange_ = this.onDescendantInputChange_.bind(this);
            this.onDescendantMonitorUpdate_ = this.onDescendantMonitorUpdate_.bind(this);
            this.emitter = new Emitter();
            this.blade_ = (_a = config.blade) !== null && _a !== void 0 ? _a : null;
            (_b = this.blade_) === null || _b === void 0 || _b.value('positions').emitter.on('change', this.onBladePositionsChange_);
            this.viewProps = config.viewProps;
            this.bcSet_ = new NestedOrderedSet(findSubBladeControllerSet);
            this.bcSet_.emitter.on('add', this.onSetAdd_);
            this.bcSet_.emitter.on('remove', this.onSetRemove_);
        }
        get children() {
            return this.bcSet_.items;
        }
        add(bc, opt_index) {
            var _a;
            (_a = bc.parent) === null || _a === void 0 || _a.remove(bc);
            if (isPropertyWritable(bc, 'parent')) bc.parent = this;
            else {
                bc['parent_'] = this;
                warnMissing({
                    key: 'parent',
                    target: 'BladeController',
                    place: 'BladeRack.add'
                });
            }
            this.bcSet_.add(bc, opt_index);
        }
        remove(bc) {
            if (isPropertyWritable(bc, 'parent')) bc.parent = null;
            else {
                bc['parent_'] = null;
                warnMissing({
                    key: 'parent',
                    target: 'BladeController',
                    place: 'BladeRack.remove'
                });
            }
            this.bcSet_.remove(bc);
        }
        find(controllerClass) {
            return forceCast(this.bcSet_.allItems().filter((bc)=>{
                return bc instanceof controllerClass;
            }));
        }
        onSetAdd_(ev) {
            this.updatePositions_();
            const isRoot = ev.target === ev.root;
            this.emitter.emit('add', {
                bladeController: ev.item,
                index: ev.index,
                isRoot: isRoot,
                sender: this
            });
            if (!isRoot) return;
            const bc = ev.item;
            bc.viewProps.emitter.on('change', this.onChildViewPropsChange_);
            bc.blade.value('positions').emitter.on('change', this.onChildPositionsChange_);
            bc.viewProps.handleDispose(this.onChildDispose_);
            if (bc instanceof InputBindingController) bc.binding.emitter.on('change', this.onChildInputChange_);
            else if (bc instanceof MonitorBindingController) bc.binding.emitter.on('update', this.onChildMonitorUpdate_);
            else if (bc instanceof ValueBladeController) bc.value.emitter.on('change', this.onChildValueChange_);
            else {
                const rack = findSubRack(bc);
                if (rack) {
                    const emitter = rack.emitter;
                    emitter.on('layout', this.onDescendantLayout_);
                    emitter.on('inputchange', this.onDescendantInputChange_);
                    emitter.on('monitorupdate', this.onDescendantMonitorUpdate_);
                }
            }
        }
        onSetRemove_(ev) {
            this.updatePositions_();
            const isRoot = ev.target === ev.root;
            this.emitter.emit('remove', {
                bladeController: ev.item,
                isRoot: isRoot,
                sender: this
            });
            if (!isRoot) return;
            const bc = ev.item;
            if (bc instanceof InputBindingController) bc.binding.emitter.off('change', this.onChildInputChange_);
            else if (bc instanceof MonitorBindingController) bc.binding.emitter.off('update', this.onChildMonitorUpdate_);
            else if (bc instanceof ValueBladeController) bc.value.emitter.off('change', this.onChildValueChange_);
            else {
                const rack = findSubRack(bc);
                if (rack) {
                    const emitter = rack.emitter;
                    emitter.off('layout', this.onDescendantLayout_);
                    emitter.off('inputchange', this.onDescendantInputChange_);
                    emitter.off('monitorupdate', this.onDescendantMonitorUpdate_);
                }
            }
        }
        updatePositions_() {
            const visibleItems = this.bcSet_.items.filter((bc)=>!bc.viewProps.get('hidden'));
            const firstVisibleItem = visibleItems[0];
            const lastVisibleItem = visibleItems[visibleItems.length - 1];
            this.bcSet_.items.forEach((bc)=>{
                const ps = [];
                if (bc === firstVisibleItem) {
                    ps.push('first');
                    if (!this.blade_ || this.blade_.get('positions').includes('veryfirst')) ps.push('veryfirst');
                }
                if (bc === lastVisibleItem) {
                    ps.push('last');
                    if (!this.blade_ || this.blade_.get('positions').includes('verylast')) ps.push('verylast');
                }
                bc.blade.set('positions', ps);
            });
        }
        onChildPositionsChange_() {
            this.updatePositions_();
            this.emitter.emit('layout', {
                sender: this
            });
        }
        onChildViewPropsChange_(_ev) {
            this.updatePositions_();
            this.emitter.emit('layout', {
                sender: this
            });
        }
        onChildDispose_() {
            const disposedUcs = this.bcSet_.items.filter((bc)=>{
                return bc.viewProps.get('disposed');
            });
            disposedUcs.forEach((bc)=>{
                this.bcSet_.remove(bc);
            });
        }
        onChildInputChange_(ev) {
            const bc = findInputBindingController(this.find(InputBindingController), ev.sender);
            if (!bc) throw TpError.alreadyDisposed();
            this.emitter.emit('inputchange', {
                bladeController: bc,
                options: ev.options,
                sender: this
            });
        }
        onChildMonitorUpdate_(ev) {
            const bc = findMonitorBindingController(this.find(MonitorBindingController), ev.sender);
            if (!bc) throw TpError.alreadyDisposed();
            this.emitter.emit('monitorupdate', {
                bladeController: bc,
                sender: this
            });
        }
        onChildValueChange_(ev) {
            const bc = findValueBladeController(this.find(ValueBladeController), ev.sender);
            if (!bc) throw TpError.alreadyDisposed();
            this.emitter.emit('inputchange', {
                bladeController: bc,
                options: ev.options,
                sender: this
            });
        }
        onDescendantLayout_(_) {
            this.updatePositions_();
            this.emitter.emit('layout', {
                sender: this
            });
        }
        onDescendantInputChange_(ev) {
            this.emitter.emit('inputchange', {
                bladeController: ev.bladeController,
                options: ev.options,
                sender: this
            });
        }
        onDescendantMonitorUpdate_(ev) {
            this.emitter.emit('monitorupdate', {
                bladeController: ev.bladeController,
                sender: this
            });
        }
        onBladePositionsChange_() {
            this.updatePositions_();
        }
    }
    class RackController extends BladeController {
        constructor(doc, config){
            super(Object.assign(Object.assign({}, config), {
                view: new PlainView(doc, {
                    viewName: 'brk',
                    viewProps: config.viewProps
                })
            }));
            this.onRackAdd_ = this.onRackAdd_.bind(this);
            this.onRackRemove_ = this.onRackRemove_.bind(this);
            const rack = new BladeRack({
                blade: config.root ? undefined : config.blade,
                viewProps: config.viewProps
            });
            rack.emitter.on('add', this.onRackAdd_);
            rack.emitter.on('remove', this.onRackRemove_);
            this.rack = rack;
            this.viewProps.handleDispose(()=>{
                for(let i = this.rack.children.length - 1; i >= 0; i--){
                    const bc = this.rack.children[i];
                    bc.viewProps.set('disposed', true);
                }
            });
        }
        onRackAdd_(ev) {
            if (!ev.isRoot) return;
            insertElementAt(this.view.element, ev.bladeController.view.element, ev.index);
        }
        onRackRemove_(ev) {
            if (!ev.isRoot) return;
            removeElement(ev.bladeController.view.element);
        }
    }
    const bladeContainerClassName = ClassName('cnt');
    class FolderView {
        constructor(doc, config){
            var _a;
            this.className_ = ClassName((_a = config.viewName) !== null && _a !== void 0 ? _a : 'fld');
            this.element = doc.createElement('div');
            this.element.classList.add(this.className_(), bladeContainerClassName());
            config.viewProps.bindClassModifiers(this.element);
            this.foldable_ = config.foldable;
            this.foldable_.bindExpandedClass(this.element, this.className_(undefined, 'expanded'));
            bindValueMap(this.foldable_, 'completed', valueToClassName(this.element, this.className_(undefined, 'cpl')));
            const buttonElem = doc.createElement('button');
            buttonElem.classList.add(this.className_('b'));
            bindValueMap(config.props, 'title', (title)=>{
                if (isEmpty(title)) this.element.classList.add(this.className_(undefined, 'not'));
                else this.element.classList.remove(this.className_(undefined, 'not'));
            });
            config.viewProps.bindDisabled(buttonElem);
            this.element.appendChild(buttonElem);
            this.buttonElement = buttonElem;
            const indentElem = doc.createElement('div');
            indentElem.classList.add(this.className_('i'));
            this.element.appendChild(indentElem);
            const titleElem = doc.createElement('div');
            titleElem.classList.add(this.className_('t'));
            bindValueToTextContent(config.props.value('title'), titleElem);
            this.buttonElement.appendChild(titleElem);
            this.titleElement = titleElem;
            const markElem = doc.createElement('div');
            markElem.classList.add(this.className_('m'));
            this.buttonElement.appendChild(markElem);
            const containerElem = config.containerElement;
            containerElem.classList.add(this.className_('c'));
            this.element.appendChild(containerElem);
            this.containerElement = containerElem;
        }
    }
    class FolderController extends RackLikeController {
        constructor(doc, config){
            var _a;
            const foldable = Foldable.create((_a = config.expanded) !== null && _a !== void 0 ? _a : true);
            const rc = new RackController(doc, {
                blade: config.blade,
                root: config.root,
                viewProps: config.viewProps
            });
            super(Object.assign(Object.assign({}, config), {
                rackController: rc,
                view: new FolderView(doc, {
                    containerElement: rc.view.element,
                    foldable: foldable,
                    props: config.props,
                    viewName: config.root ? 'rot' : undefined,
                    viewProps: config.viewProps
                })
            }));
            this.onTitleClick_ = this.onTitleClick_.bind(this);
            this.props = config.props;
            this.foldable = foldable;
            bindFoldable(this.foldable, this.view.containerElement);
            this.rackController.rack.emitter.on('add', ()=>{
                this.foldable.cleanUpTransition();
            });
            this.rackController.rack.emitter.on('remove', ()=>{
                this.foldable.cleanUpTransition();
            });
            this.view.buttonElement.addEventListener('click', this.onTitleClick_);
        }
        get document() {
            return this.view.element.ownerDocument;
        }
        onTitleClick_() {
            this.foldable.set('expanded', !this.foldable.get('expanded'));
        }
    }
    const FolderBladePlugin = {
        id: 'folder',
        type: 'blade',
        accept (params) {
            const p = ParamsParsers;
            const result = parseParams(params, {
                title: p.required.string,
                view: p.required.constant('folder'),
                expanded: p.optional.boolean
            });
            return result ? {
                params: result
            } : null;
        },
        controller (args) {
            return new FolderController(args.document, {
                blade: args.blade,
                expanded: args.params.expanded,
                props: ValueMap.fromObject({
                    title: args.params.title
                }),
                viewProps: args.viewProps
            });
        },
        api (args) {
            if (!(args.controller instanceof FolderController)) return null;
            return new FolderApi(args.controller, args.pool);
        }
    };
    class LabeledValueController extends ValueBladeController {
        constructor(doc, config){
            const viewProps = config.valueController.viewProps;
            super(Object.assign(Object.assign({}, config), {
                value: config.valueController.value,
                view: new LabelView(doc, {
                    props: config.props,
                    viewProps: viewProps
                }),
                viewProps: viewProps
            }));
            this.props = config.props;
            this.valueController = config.valueController;
            this.view.valueElement.appendChild(this.valueController.view.element);
        }
    }
    class SeparatorApi extends BladeApi {
    }
    const className$m = ClassName('spr');
    class SeparatorView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$m());
            config.viewProps.bindClassModifiers(this.element);
            const hrElem = doc.createElement('hr');
            hrElem.classList.add(className$m('r'));
            this.element.appendChild(hrElem);
        }
    }
    class SeparatorController extends BladeController {
        constructor(doc, config){
            super(Object.assign(Object.assign({}, config), {
                view: new SeparatorView(doc, {
                    viewProps: config.viewProps
                })
            }));
        }
    }
    const SeparatorBladePlugin = {
        id: 'separator',
        type: 'blade',
        accept (params) {
            const p = ParamsParsers;
            const result = parseParams(params, {
                view: p.required.constant('separator')
            });
            return result ? {
                params: result
            } : null;
        },
        controller (args) {
            return new SeparatorController(args.document, {
                blade: args.blade,
                viewProps: args.viewProps
            });
        },
        api (args) {
            if (!(args.controller instanceof SeparatorController)) return null;
            return new SeparatorApi(args.controller);
        }
    };
    const className$l = ClassName('tbi');
    class TabItemView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$l());
            config.viewProps.bindClassModifiers(this.element);
            bindValueMap(config.props, 'selected', (selected)=>{
                if (selected) this.element.classList.add(className$l(undefined, 'sel'));
                else this.element.classList.remove(className$l(undefined, 'sel'));
            });
            const buttonElem = doc.createElement('button');
            buttonElem.classList.add(className$l('b'));
            config.viewProps.bindDisabled(buttonElem);
            this.element.appendChild(buttonElem);
            this.buttonElement = buttonElem;
            const titleElem = doc.createElement('div');
            titleElem.classList.add(className$l('t'));
            bindValueToTextContent(config.props.value('title'), titleElem);
            this.buttonElement.appendChild(titleElem);
            this.titleElement = titleElem;
        }
    }
    class TabItemController {
        constructor(doc, config){
            this.emitter = new Emitter();
            this.onClick_ = this.onClick_.bind(this);
            this.props = config.props;
            this.viewProps = config.viewProps;
            this.view = new TabItemView(doc, {
                props: config.props,
                viewProps: config.viewProps
            });
            this.view.buttonElement.addEventListener('click', this.onClick_);
        }
        onClick_() {
            this.emitter.emit('click', {
                sender: this
            });
        }
    }
    class TabPageController {
        constructor(doc, config){
            this.onItemClick_ = this.onItemClick_.bind(this);
            this.ic_ = new TabItemController(doc, {
                props: config.itemProps,
                viewProps: ViewProps.create()
            });
            this.ic_.emitter.on('click', this.onItemClick_);
            this.cc_ = new RackController(doc, {
                blade: createBlade(),
                viewProps: ViewProps.create()
            });
            this.props = config.props;
            bindValueMap(this.props, 'selected', (selected)=>{
                this.itemController.props.set('selected', selected);
                this.contentController.viewProps.set('hidden', !selected);
            });
        }
        get itemController() {
            return this.ic_;
        }
        get contentController() {
            return this.cc_;
        }
        onItemClick_() {
            this.props.set('selected', true);
        }
    }
    class TabPageApi {
        constructor(controller, contentRackApi){
            this.controller_ = controller;
            this.rackApi_ = contentRackApi;
        }
        get title() {
            var _a;
            return (_a = this.controller_.itemController.props.get('title')) !== null && _a !== void 0 ? _a : '';
        }
        set title(title) {
            this.controller_.itemController.props.set('title', title);
        }
        get selected() {
            return this.controller_.props.get('selected');
        }
        set selected(selected) {
            this.controller_.props.set('selected', selected);
        }
        get children() {
            return this.rackApi_.children;
        }
        addButton(params) {
            return this.rackApi_.addButton(params);
        }
        addFolder(params) {
            return this.rackApi_.addFolder(params);
        }
        addSeparator(opt_params) {
            return this.rackApi_.addSeparator(opt_params);
        }
        addTab(params) {
            return this.rackApi_.addTab(params);
        }
        add(api, opt_index) {
            this.rackApi_.add(api, opt_index);
        }
        remove(api) {
            this.rackApi_.remove(api);
        }
        addInput(object, key, opt_params) {
            return this.rackApi_.addInput(object, key, opt_params);
        }
        addMonitor(object, key, opt_params) {
            return this.rackApi_.addMonitor(object, key, opt_params);
        }
        addBlade(params) {
            return this.rackApi_.addBlade(params);
        }
    }
    class TabApi extends RackLikeApi {
        constructor(controller, pool){
            super(controller, new RackApi(controller.rackController, pool));
            this.onPageAdd_ = this.onPageAdd_.bind(this);
            this.onPageRemove_ = this.onPageRemove_.bind(this);
            this.onSelect_ = this.onSelect_.bind(this);
            this.emitter_ = new Emitter();
            this.pageApiMap_ = new Map();
            this.rackApi_.on('change', (ev)=>{
                this.emitter_.emit('change', {
                    event: ev
                });
            });
            this.rackApi_.on('update', (ev)=>{
                this.emitter_.emit('update', {
                    event: ev
                });
            });
            this.controller_.tab.selectedIndex.emitter.on('change', this.onSelect_);
            this.controller_.pageSet.emitter.on('add', this.onPageAdd_);
            this.controller_.pageSet.emitter.on('remove', this.onPageRemove_);
            this.controller_.pageSet.items.forEach((pc)=>{
                this.setUpPageApi_(pc);
            });
        }
        get pages() {
            return this.controller_.pageSet.items.map((pc)=>{
                const api = this.pageApiMap_.get(pc);
                if (!api) throw TpError.shouldNeverHappen();
                return api;
            });
        }
        addPage(params) {
            const doc = this.controller_.view.element.ownerDocument;
            const pc = new TabPageController(doc, {
                itemProps: ValueMap.fromObject({
                    selected: false,
                    title: params.title
                }),
                props: ValueMap.fromObject({
                    selected: false
                })
            });
            this.controller_.add(pc, params.index);
            const api = this.pageApiMap_.get(pc);
            if (!api) throw TpError.shouldNeverHappen();
            return api;
        }
        removePage(index) {
            this.controller_.remove(index);
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
        setUpPageApi_(pc) {
            const rackApi = this.rackApi_['apiSet_'].find((api)=>api.controller_ === pc.contentController);
            if (!rackApi) throw TpError.shouldNeverHappen();
            const api = new TabPageApi(pc, rackApi);
            this.pageApiMap_.set(pc, api);
        }
        onPageAdd_(ev) {
            this.setUpPageApi_(ev.item);
        }
        onPageRemove_(ev) {
            const api = this.pageApiMap_.get(ev.item);
            if (!api) throw TpError.shouldNeverHappen();
            this.pageApiMap_.delete(ev.item);
        }
        onSelect_(ev) {
            this.emitter_.emit('select', {
                event: new TpTabSelectEvent(this, ev.rawValue)
            });
        }
    }
    const INDEX_NOT_SELECTED = -1;
    class Tab {
        constructor(){
            this.onItemSelectedChange_ = this.onItemSelectedChange_.bind(this);
            this.empty = createValue(true);
            this.selectedIndex = createValue(INDEX_NOT_SELECTED);
            this.items_ = [];
        }
        add(item, opt_index) {
            const index = opt_index !== null && opt_index !== void 0 ? opt_index : this.items_.length;
            this.items_.splice(index, 0, item);
            item.emitter.on('change', this.onItemSelectedChange_);
            this.keepSelection_();
        }
        remove(item) {
            const index = this.items_.indexOf(item);
            if (index < 0) return;
            this.items_.splice(index, 1);
            item.emitter.off('change', this.onItemSelectedChange_);
            this.keepSelection_();
        }
        keepSelection_() {
            if (this.items_.length === 0) {
                this.selectedIndex.rawValue = INDEX_NOT_SELECTED;
                this.empty.rawValue = true;
                return;
            }
            const firstSelIndex = this.items_.findIndex((s)=>s.rawValue);
            if (firstSelIndex < 0) {
                this.items_.forEach((s, i)=>{
                    s.rawValue = i === 0;
                });
                this.selectedIndex.rawValue = 0;
            } else {
                this.items_.forEach((s, i)=>{
                    s.rawValue = i === firstSelIndex;
                });
                this.selectedIndex.rawValue = firstSelIndex;
            }
            this.empty.rawValue = false;
        }
        onItemSelectedChange_(ev) {
            if (ev.rawValue) {
                const index = this.items_.findIndex((s)=>s === ev.sender);
                this.items_.forEach((s, i)=>{
                    s.rawValue = i === index;
                });
                this.selectedIndex.rawValue = index;
            } else this.keepSelection_();
        }
    }
    const className$k = ClassName('tab');
    class TabView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$k(), bladeContainerClassName());
            config.viewProps.bindClassModifiers(this.element);
            bindValue(config.empty, valueToClassName(this.element, className$k(undefined, 'nop')));
            const titleElem = doc.createElement('div');
            titleElem.classList.add(className$k('t'));
            this.element.appendChild(titleElem);
            this.itemsElement = titleElem;
            const indentElem = doc.createElement('div');
            indentElem.classList.add(className$k('i'));
            this.element.appendChild(indentElem);
            const contentsElem = config.contentsElement;
            contentsElem.classList.add(className$k('c'));
            this.element.appendChild(contentsElem);
            this.contentsElement = contentsElem;
        }
    }
    class TabController extends RackLikeController {
        constructor(doc, config){
            const cr = new RackController(doc, {
                blade: config.blade,
                viewProps: config.viewProps
            });
            const tab = new Tab();
            super({
                blade: config.blade,
                rackController: cr,
                view: new TabView(doc, {
                    contentsElement: cr.view.element,
                    empty: tab.empty,
                    viewProps: config.viewProps
                })
            });
            this.onPageAdd_ = this.onPageAdd_.bind(this);
            this.onPageRemove_ = this.onPageRemove_.bind(this);
            this.pageSet_ = new NestedOrderedSet(()=>null);
            this.pageSet_.emitter.on('add', this.onPageAdd_);
            this.pageSet_.emitter.on('remove', this.onPageRemove_);
            this.tab = tab;
        }
        get pageSet() {
            return this.pageSet_;
        }
        add(pc, opt_index) {
            this.pageSet_.add(pc, opt_index);
        }
        remove(index) {
            this.pageSet_.remove(this.pageSet_.items[index]);
        }
        onPageAdd_(ev) {
            const pc = ev.item;
            insertElementAt(this.view.itemsElement, pc.itemController.view.element, ev.index);
            pc.itemController.viewProps.set('parent', this.viewProps);
            this.rackController.rack.add(pc.contentController, ev.index);
            this.tab.add(pc.props.value('selected'));
        }
        onPageRemove_(ev) {
            const pc = ev.item;
            removeElement(pc.itemController.view.element);
            pc.itemController.viewProps.set('parent', null);
            this.rackController.rack.remove(pc.contentController);
            this.tab.remove(pc.props.value('selected'));
        }
    }
    const TabBladePlugin = {
        id: 'tab',
        type: 'blade',
        accept (params) {
            const p = ParamsParsers;
            const result = parseParams(params, {
                pages: p.required.array(p.required.object({
                    title: p.required.string
                })),
                view: p.required.constant('tab')
            });
            if (!result || result.pages.length === 0) return null;
            return {
                params: result
            };
        },
        controller (args) {
            const c = new TabController(args.document, {
                blade: args.blade,
                viewProps: args.viewProps
            });
            args.params.pages.forEach((p)=>{
                const pc = new TabPageController(args.document, {
                    itemProps: ValueMap.fromObject({
                        selected: false,
                        title: p.title
                    }),
                    props: ValueMap.fromObject({
                        selected: false
                    })
                });
                c.add(pc);
            });
            return c;
        },
        api (args) {
            if (!(args.controller instanceof TabController)) return null;
            return new TabApi(args.controller, args.pool);
        }
    };
    function createBladeController(plugin, args) {
        const ac = plugin.accept(args.params);
        if (!ac) return null;
        const disabled = ParamsParsers.optional.boolean(args.params['disabled']).value;
        const hidden = ParamsParsers.optional.boolean(args.params['hidden']).value;
        return plugin.controller({
            blade: createBlade(),
            document: args.document,
            params: forceCast(Object.assign(Object.assign({}, ac.params), {
                disabled: disabled,
                hidden: hidden
            })),
            viewProps: ViewProps.create({
                disabled: disabled,
                hidden: hidden
            })
        });
    }
    class ManualTicker {
        constructor(){
            this.disabled = false;
            this.emitter = new Emitter();
        }
        dispose() {}
        tick() {
            if (this.disabled) return;
            this.emitter.emit('tick', {
                sender: this
            });
        }
    }
    class IntervalTicker {
        constructor(doc, interval){
            this.disabled_ = false;
            this.timerId_ = null;
            this.onTick_ = this.onTick_.bind(this);
            this.doc_ = doc;
            this.emitter = new Emitter();
            this.interval_ = interval;
            this.setTimer_();
        }
        get disabled() {
            return this.disabled_;
        }
        set disabled(inactive) {
            this.disabled_ = inactive;
            if (this.disabled_) this.clearTimer_();
            else this.setTimer_();
        }
        dispose() {
            this.clearTimer_();
        }
        clearTimer_() {
            if (this.timerId_ === null) return;
            const win = this.doc_.defaultView;
            if (win) win.clearInterval(this.timerId_);
            this.timerId_ = null;
        }
        setTimer_() {
            this.clearTimer_();
            if (this.interval_ <= 0) return;
            const win = this.doc_.defaultView;
            if (win) this.timerId_ = win.setInterval(this.onTick_, this.interval_);
        }
        onTick_() {
            if (this.disabled_) return;
            this.emitter.emit('tick', {
                sender: this
            });
        }
    }
    class InputBinding {
        constructor(config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.reader = config.reader;
            this.writer = config.writer;
            this.emitter = new Emitter();
            this.value = config.value;
            this.value.emitter.on('change', this.onValueChange_);
            this.target = config.target;
            this.read();
        }
        read() {
            const targetValue = this.target.read();
            if (targetValue !== undefined) this.value.rawValue = this.reader(targetValue);
        }
        write_(rawValue) {
            this.writer(this.target, rawValue);
        }
        onValueChange_(ev) {
            this.write_(ev.rawValue);
            this.emitter.emit('change', {
                options: ev.options,
                rawValue: ev.rawValue,
                sender: this
            });
        }
    }
    function fillBuffer(buffer, bufferSize) {
        while(buffer.length < bufferSize)buffer.push(undefined);
    }
    function initializeBuffer(bufferSize) {
        const buffer = [];
        fillBuffer(buffer, bufferSize);
        return createValue(buffer);
    }
    function createTrimmedBuffer(buffer) {
        const index = buffer.indexOf(undefined);
        return forceCast(index < 0 ? buffer : buffer.slice(0, index));
    }
    function createPushedBuffer(buffer, newValue) {
        const newBuffer = [
            ...createTrimmedBuffer(buffer),
            newValue
        ];
        if (newBuffer.length > buffer.length) newBuffer.splice(0, newBuffer.length - buffer.length);
        else fillBuffer(newBuffer, buffer.length);
        return newBuffer;
    }
    class MonitorBinding {
        constructor(config){
            this.onTick_ = this.onTick_.bind(this);
            this.reader_ = config.reader;
            this.target = config.target;
            this.emitter = new Emitter();
            this.value = config.value;
            this.ticker = config.ticker;
            this.ticker.emitter.on('tick', this.onTick_);
            this.read();
        }
        dispose() {
            this.ticker.dispose();
        }
        read() {
            const targetValue = this.target.read();
            if (targetValue === undefined) return;
            const buffer = this.value.rawValue;
            const newValue = this.reader_(targetValue);
            this.value.rawValue = createPushedBuffer(buffer, newValue);
            this.emitter.emit('update', {
                rawValue: newValue,
                sender: this
            });
        }
        onTick_(_) {
            this.read();
        }
    }
    class CompositeConstraint {
        constructor(constraints){
            this.constraints = constraints;
        }
        constrain(value) {
            return this.constraints.reduce((result, c)=>{
                return c.constrain(result);
            }, value);
        }
    }
    function findConstraint(c, constraintClass) {
        if (c instanceof constraintClass) return c;
        if (c instanceof CompositeConstraint) {
            const result = c.constraints.reduce((tmpResult, sc)=>{
                if (tmpResult) return tmpResult;
                return sc instanceof constraintClass ? sc : null;
            }, null);
            if (result) return result;
        }
        return null;
    }
    class DefiniteRangeConstraint {
        constructor(config){
            this.values = ValueMap.fromObject({
                max: config.max,
                min: config.min
            });
        }
        constrain(value) {
            const max = this.values.get('max');
            const min = this.values.get('min');
            return Math.min(Math.max(value, min), max);
        }
    }
    class ListConstraint {
        constructor(options){
            this.values = ValueMap.fromObject({
                options: options
            });
        }
        get options() {
            return this.values.get('options');
        }
        constrain(value) {
            const opts = this.values.get('options');
            if (opts.length === 0) return value;
            const matched = opts.filter((item)=>{
                return item.value === value;
            }).length > 0;
            return matched ? value : opts[0].value;
        }
    }
    class RangeConstraint {
        constructor(config){
            this.values = ValueMap.fromObject({
                max: config.max,
                min: config.min
            });
        }
        get maxValue() {
            return this.values.get('max');
        }
        get minValue() {
            return this.values.get('min');
        }
        constrain(value) {
            const max = this.values.get('max');
            const min = this.values.get('min');
            let result = value;
            if (!isEmpty(min)) result = Math.max(result, min);
            if (!isEmpty(max)) result = Math.min(result, max);
            return result;
        }
    }
    class StepConstraint {
        constructor(step, origin = 0){
            this.step = step;
            this.origin = origin;
        }
        constrain(value) {
            const o = this.origin % this.step;
            const r = Math.round((value - o) / this.step);
            return o + r * this.step;
        }
    }
    const className$j = ClassName('lst');
    class ListView {
        constructor(doc, config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.props_ = config.props;
            this.element = doc.createElement('div');
            this.element.classList.add(className$j());
            config.viewProps.bindClassModifiers(this.element);
            const selectElem = doc.createElement('select');
            selectElem.classList.add(className$j('s'));
            config.viewProps.bindDisabled(selectElem);
            this.element.appendChild(selectElem);
            this.selectElement = selectElem;
            const markElem = doc.createElement('div');
            markElem.classList.add(className$j('m'));
            markElem.appendChild(createSvgIconElement(doc, 'dropdown'));
            this.element.appendChild(markElem);
            config.value.emitter.on('change', this.onValueChange_);
            this.value_ = config.value;
            bindValueMap(this.props_, 'options', (opts)=>{
                removeChildElements(this.selectElement);
                opts.forEach((item)=>{
                    const optionElem = doc.createElement('option');
                    optionElem.textContent = item.text;
                    this.selectElement.appendChild(optionElem);
                });
                this.update_();
            });
        }
        update_() {
            const values = this.props_.get('options').map((o)=>o.value);
            this.selectElement.selectedIndex = values.indexOf(this.value_.rawValue);
        }
        onValueChange_() {
            this.update_();
        }
    }
    class ListController {
        constructor(doc, config){
            this.onSelectChange_ = this.onSelectChange_.bind(this);
            this.props = config.props;
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new ListView(doc, {
                props: this.props,
                value: this.value,
                viewProps: this.viewProps
            });
            this.view.selectElement.addEventListener('change', this.onSelectChange_);
        }
        onSelectChange_(e) {
            const selectElem = forceCast(e.currentTarget);
            this.value.rawValue = this.props.get('options')[selectElem.selectedIndex].value;
        }
    }
    const className$i = ClassName('pop');
    class PopupView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$i());
            config.viewProps.bindClassModifiers(this.element);
            bindValue(config.shows, valueToClassName(this.element, className$i(undefined, 'v')));
        }
    }
    class PopupController {
        constructor(doc, config){
            this.shows = createValue(false);
            this.viewProps = config.viewProps;
            this.view = new PopupView(doc, {
                shows: this.shows,
                viewProps: this.viewProps
            });
        }
    }
    const className$h = ClassName('txt');
    class TextView {
        constructor(doc, config){
            this.onChange_ = this.onChange_.bind(this);
            this.element = doc.createElement('div');
            this.element.classList.add(className$h());
            config.viewProps.bindClassModifiers(this.element);
            this.props_ = config.props;
            this.props_.emitter.on('change', this.onChange_);
            const inputElem = doc.createElement('input');
            inputElem.classList.add(className$h('i'));
            inputElem.type = 'text';
            config.viewProps.bindDisabled(inputElem);
            this.element.appendChild(inputElem);
            this.inputElement = inputElem;
            config.value.emitter.on('change', this.onChange_);
            this.value_ = config.value;
            this.refresh();
        }
        refresh() {
            const formatter = this.props_.get('formatter');
            this.inputElement.value = formatter(this.value_.rawValue);
        }
        onChange_() {
            this.refresh();
        }
    }
    class TextController {
        constructor(doc, config){
            this.onInputChange_ = this.onInputChange_.bind(this);
            this.parser_ = config.parser;
            this.props = config.props;
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new TextView(doc, {
                props: config.props,
                value: this.value,
                viewProps: this.viewProps
            });
            this.view.inputElement.addEventListener('change', this.onInputChange_);
        }
        onInputChange_(e) {
            const inputElem = forceCast(e.currentTarget);
            const value = inputElem.value;
            const parsedValue = this.parser_(value);
            if (!isEmpty(parsedValue)) this.value.rawValue = parsedValue;
            this.view.refresh();
        }
    }
    function boolToString(value) {
        return String(value);
    }
    function boolFromUnknown(value) {
        if (value === 'false') return false;
        return !!value;
    }
    function BooleanFormatter(value) {
        return boolToString(value);
    }
    class NumberLiteralNode {
        constructor(text){
            this.text = text;
        }
        evaluate() {
            return Number(this.text);
        }
        toString() {
            return this.text;
        }
    }
    const BINARY_OPERATION_MAP = {
        '**': (v1, v2)=>Math.pow(v1, v2),
        '*': (v1, v2)=>v1 * v2,
        '/': (v1, v2)=>v1 / v2,
        '%': (v1, v2)=>v1 % v2,
        '+': (v1, v2)=>v1 + v2,
        '-': (v1, v2)=>v1 - v2,
        '<<': (v1, v2)=>v1 << v2,
        '>>': (v1, v2)=>v1 >> v2,
        '>>>': (v1, v2)=>v1 >>> v2,
        '&': (v1, v2)=>v1 & v2,
        '^': (v1, v2)=>v1 ^ v2,
        '|': (v1, v2)=>v1 | v2
    };
    class BinaryOperationNode {
        constructor(operator, left, right){
            this.left = left;
            this.operator = operator;
            this.right = right;
        }
        evaluate() {
            const op = BINARY_OPERATION_MAP[this.operator];
            if (!op) throw new Error(`unexpected binary operator: '${this.operator}`);
            return op(this.left.evaluate(), this.right.evaluate());
        }
        toString() {
            return [
                'b(',
                this.left.toString(),
                this.operator,
                this.right.toString(),
                ')'
            ].join(' ');
        }
    }
    const UNARY_OPERATION_MAP = {
        '+': (v)=>v,
        '-': (v)=>-v,
        '~': (v)=>~v
    };
    class UnaryOperationNode {
        constructor(operator, expr){
            this.operator = operator;
            this.expression = expr;
        }
        evaluate() {
            const op = UNARY_OPERATION_MAP[this.operator];
            if (!op) throw new Error(`unexpected unary operator: '${this.operator}`);
            return op(this.expression.evaluate());
        }
        toString() {
            return [
                'u(',
                this.operator,
                this.expression.toString(),
                ')'
            ].join(' ');
        }
    }
    function combineReader(parsers) {
        return (text, cursor)=>{
            for(let i = 0; i < parsers.length; i++){
                const result = parsers[i](text, cursor);
                if (result !== '') return result;
            }
            return '';
        };
    }
    function readWhitespace(text, cursor) {
        var _a;
        const m = text.substr(cursor).match(/^\s+/);
        return (_a = m && m[0]) !== null && _a !== void 0 ? _a : '';
    }
    function readNonZeroDigit(text, cursor) {
        const ch = text.substr(cursor, 1);
        return ch.match(/^[1-9]$/) ? ch : '';
    }
    function readDecimalDigits(text, cursor) {
        var _a;
        const m = text.substr(cursor).match(/^[0-9]+/);
        return (_a = m && m[0]) !== null && _a !== void 0 ? _a : '';
    }
    function readSignedInteger(text, cursor) {
        const ds = readDecimalDigits(text, cursor);
        if (ds !== '') return ds;
        const sign = text.substr(cursor, 1);
        cursor += 1;
        if (sign !== '-' && sign !== '+') return '';
        const sds = readDecimalDigits(text, cursor);
        if (sds === '') return '';
        return sign + sds;
    }
    function readExponentPart(text, cursor) {
        const e = text.substr(cursor, 1);
        cursor += 1;
        if (e.toLowerCase() !== 'e') return '';
        const si = readSignedInteger(text, cursor);
        if (si === '') return '';
        return e + si;
    }
    function readDecimalIntegerLiteral(text, cursor) {
        const ch = text.substr(cursor, 1);
        if (ch === '0') return ch;
        const nzd = readNonZeroDigit(text, cursor);
        cursor += nzd.length;
        if (nzd === '') return '';
        return nzd + readDecimalDigits(text, cursor);
    }
    function readDecimalLiteral1(text, cursor) {
        const dil = readDecimalIntegerLiteral(text, cursor);
        cursor += dil.length;
        if (dil === '') return '';
        const dot = text.substr(cursor, 1);
        cursor += dot.length;
        if (dot !== '.') return '';
        const dds = readDecimalDigits(text, cursor);
        cursor += dds.length;
        return dil + dot + dds + readExponentPart(text, cursor);
    }
    function readDecimalLiteral2(text, cursor) {
        const dot = text.substr(cursor, 1);
        cursor += dot.length;
        if (dot !== '.') return '';
        const dds = readDecimalDigits(text, cursor);
        cursor += dds.length;
        if (dds === '') return '';
        return dot + dds + readExponentPart(text, cursor);
    }
    function readDecimalLiteral3(text, cursor) {
        const dil = readDecimalIntegerLiteral(text, cursor);
        cursor += dil.length;
        if (dil === '') return '';
        return dil + readExponentPart(text, cursor);
    }
    const readDecimalLiteral = combineReader([
        readDecimalLiteral1,
        readDecimalLiteral2,
        readDecimalLiteral3
    ]);
    function parseBinaryDigits(text, cursor) {
        var _a;
        const m = text.substr(cursor).match(/^[01]+/);
        return (_a = m && m[0]) !== null && _a !== void 0 ? _a : '';
    }
    function readBinaryIntegerLiteral(text, cursor) {
        const prefix = text.substr(cursor, 2);
        cursor += prefix.length;
        if (prefix.toLowerCase() !== '0b') return '';
        const bds = parseBinaryDigits(text, cursor);
        if (bds === '') return '';
        return prefix + bds;
    }
    function readOctalDigits(text, cursor) {
        var _a;
        const m = text.substr(cursor).match(/^[0-7]+/);
        return (_a = m && m[0]) !== null && _a !== void 0 ? _a : '';
    }
    function readOctalIntegerLiteral(text, cursor) {
        const prefix = text.substr(cursor, 2);
        cursor += prefix.length;
        if (prefix.toLowerCase() !== '0o') return '';
        const ods = readOctalDigits(text, cursor);
        if (ods === '') return '';
        return prefix + ods;
    }
    function readHexDigits(text, cursor) {
        var _a;
        const m = text.substr(cursor).match(/^[0-9a-f]+/i);
        return (_a = m && m[0]) !== null && _a !== void 0 ? _a : '';
    }
    function readHexIntegerLiteral(text, cursor) {
        const prefix = text.substr(cursor, 2);
        cursor += prefix.length;
        if (prefix.toLowerCase() !== '0x') return '';
        const hds = readHexDigits(text, cursor);
        if (hds === '') return '';
        return prefix + hds;
    }
    const readNonDecimalIntegerLiteral = combineReader([
        readBinaryIntegerLiteral,
        readOctalIntegerLiteral,
        readHexIntegerLiteral
    ]);
    const readNumericLiteral = combineReader([
        readNonDecimalIntegerLiteral,
        readDecimalLiteral
    ]);
    function parseLiteral(text, cursor) {
        const num = readNumericLiteral(text, cursor);
        cursor += num.length;
        if (num === '') return null;
        return {
            evaluable: new NumberLiteralNode(num),
            cursor: cursor
        };
    }
    function parseParenthesizedExpression(text, cursor) {
        const op = text.substr(cursor, 1);
        cursor += op.length;
        if (op !== '(') return null;
        const expr = parseExpression(text, cursor);
        if (!expr) return null;
        cursor = expr.cursor;
        cursor += readWhitespace(text, cursor).length;
        const cl = text.substr(cursor, 1);
        cursor += cl.length;
        if (cl !== ')') return null;
        return {
            evaluable: expr.evaluable,
            cursor: cursor
        };
    }
    function parsePrimaryExpression(text, cursor) {
        var _a;
        return (_a = parseLiteral(text, cursor)) !== null && _a !== void 0 ? _a : parseParenthesizedExpression(text, cursor);
    }
    function parseUnaryExpression(text, cursor) {
        const expr = parsePrimaryExpression(text, cursor);
        if (expr) return expr;
        const op = text.substr(cursor, 1);
        cursor += op.length;
        if (op !== '+' && op !== '-' && op !== '~') return null;
        const num = parseUnaryExpression(text, cursor);
        if (!num) return null;
        cursor = num.cursor;
        return {
            cursor: cursor,
            evaluable: new UnaryOperationNode(op, num.evaluable)
        };
    }
    function readBinaryOperator(ops, text, cursor) {
        cursor += readWhitespace(text, cursor).length;
        const op = ops.filter((op)=>text.startsWith(op, cursor))[0];
        if (!op) return null;
        cursor += op.length;
        cursor += readWhitespace(text, cursor).length;
        return {
            cursor: cursor,
            operator: op
        };
    }
    function createBinaryOperationExpressionParser(exprParser, ops) {
        return (text, cursor)=>{
            const firstExpr = exprParser(text, cursor);
            if (!firstExpr) return null;
            cursor = firstExpr.cursor;
            let expr = firstExpr.evaluable;
            for(;;){
                const op = readBinaryOperator(ops, text, cursor);
                if (!op) break;
                cursor = op.cursor;
                const nextExpr = exprParser(text, cursor);
                if (!nextExpr) return null;
                cursor = nextExpr.cursor;
                expr = new BinaryOperationNode(op.operator, expr, nextExpr.evaluable);
            }
            return expr ? {
                cursor: cursor,
                evaluable: expr
            } : null;
        };
    }
    const parseBinaryOperationExpression = [
        [
            '**'
        ],
        [
            '*',
            '/',
            '%'
        ],
        [
            '+',
            '-'
        ],
        [
            '<<',
            '>>>',
            '>>'
        ],
        [
            '&'
        ],
        [
            '^'
        ],
        [
            '|'
        ]
    ].reduce((parser, ops)=>{
        return createBinaryOperationExpressionParser(parser, ops);
    }, parseUnaryExpression);
    function parseExpression(text, cursor) {
        cursor += readWhitespace(text, cursor).length;
        return parseBinaryOperationExpression(text, cursor);
    }
    function parseEcmaNumberExpression(text) {
        const expr = parseExpression(text, 0);
        if (!expr) return null;
        const cursor = expr.cursor + readWhitespace(text, expr.cursor).length;
        if (cursor !== text.length) return null;
        return expr.evaluable;
    }
    function parseNumber(text) {
        var _a;
        const r = parseEcmaNumberExpression(text);
        return (_a = r === null || r === void 0 ? void 0 : r.evaluate()) !== null && _a !== void 0 ? _a : null;
    }
    function numberFromUnknown(value) {
        if (typeof value === 'number') return value;
        if (typeof value === 'string') {
            const pv = parseNumber(value);
            if (!isEmpty(pv)) return pv;
        }
        return 0;
    }
    function numberToString(value) {
        return String(value);
    }
    function createNumberFormatter(digits) {
        return (value)=>{
            return value.toFixed(Math.max(Math.min(digits, 20), 0));
        };
    }
    const innerFormatter = createNumberFormatter(0);
    function formatPercentage(value) {
        return innerFormatter(value) + '%';
    }
    function stringFromUnknown(value) {
        return String(value);
    }
    function formatString(value) {
        return value;
    }
    function connectValues({ primary: primary, secondary: secondary, forward: forward, backward: backward }) {
        let changing = false;
        function preventFeedback(callback) {
            if (changing) return;
            changing = true;
            callback();
            changing = false;
        }
        primary.emitter.on('change', (ev)=>{
            preventFeedback(()=>{
                secondary.setRawValue(forward(primary, secondary), ev.options);
            });
        });
        secondary.emitter.on('change', (ev)=>{
            preventFeedback(()=>{
                primary.setRawValue(backward(primary, secondary), ev.options);
            });
            preventFeedback(()=>{
                secondary.setRawValue(forward(primary, secondary), ev.options);
            });
        });
        preventFeedback(()=>{
            secondary.setRawValue(forward(primary, secondary), {
                forceEmit: false,
                last: true
            });
        });
    }
    function getStepForKey(baseStep, keys) {
        const step = baseStep * (keys.altKey ? 0.1 : 1) * (keys.shiftKey ? 10 : 1);
        if (keys.upKey) return +step;
        else if (keys.downKey) return -step;
        return 0;
    }
    function getVerticalStepKeys(ev) {
        return {
            altKey: ev.altKey,
            downKey: ev.key === 'ArrowDown',
            shiftKey: ev.shiftKey,
            upKey: ev.key === 'ArrowUp'
        };
    }
    function getHorizontalStepKeys(ev) {
        return {
            altKey: ev.altKey,
            downKey: ev.key === 'ArrowLeft',
            shiftKey: ev.shiftKey,
            upKey: ev.key === 'ArrowRight'
        };
    }
    function isVerticalArrowKey(key) {
        return key === 'ArrowUp' || key === 'ArrowDown';
    }
    function isArrowKey(key) {
        return isVerticalArrowKey(key) || key === 'ArrowLeft' || key === 'ArrowRight';
    }
    function computeOffset$1(ev, elem) {
        var _a, _b;
        const win = elem.ownerDocument.defaultView;
        const rect = elem.getBoundingClientRect();
        return {
            x: ev.pageX - (((_a = win && win.scrollX) !== null && _a !== void 0 ? _a : 0) + rect.left),
            y: ev.pageY - (((_b = win && win.scrollY) !== null && _b !== void 0 ? _b : 0) + rect.top)
        };
    }
    class PointerHandler {
        constructor(element){
            this.lastTouch_ = null;
            this.onDocumentMouseMove_ = this.onDocumentMouseMove_.bind(this);
            this.onDocumentMouseUp_ = this.onDocumentMouseUp_.bind(this);
            this.onMouseDown_ = this.onMouseDown_.bind(this);
            this.onTouchEnd_ = this.onTouchEnd_.bind(this);
            this.onTouchMove_ = this.onTouchMove_.bind(this);
            this.onTouchStart_ = this.onTouchStart_.bind(this);
            this.elem_ = element;
            this.emitter = new Emitter();
            element.addEventListener('touchstart', this.onTouchStart_, {
                passive: false
            });
            element.addEventListener('touchmove', this.onTouchMove_, {
                passive: true
            });
            element.addEventListener('touchend', this.onTouchEnd_);
            element.addEventListener('mousedown', this.onMouseDown_);
        }
        computePosition_(offset) {
            const rect = this.elem_.getBoundingClientRect();
            return {
                bounds: {
                    width: rect.width,
                    height: rect.height
                },
                point: offset ? {
                    x: offset.x,
                    y: offset.y
                } : null
            };
        }
        onMouseDown_(ev) {
            var _a;
            ev.preventDefault();
            (_a = ev.currentTarget) === null || _a === void 0 || _a.focus();
            const doc = this.elem_.ownerDocument;
            doc.addEventListener('mousemove', this.onDocumentMouseMove_);
            doc.addEventListener('mouseup', this.onDocumentMouseUp_);
            this.emitter.emit('down', {
                altKey: ev.altKey,
                data: this.computePosition_(computeOffset$1(ev, this.elem_)),
                sender: this,
                shiftKey: ev.shiftKey
            });
        }
        onDocumentMouseMove_(ev) {
            this.emitter.emit('move', {
                altKey: ev.altKey,
                data: this.computePosition_(computeOffset$1(ev, this.elem_)),
                sender: this,
                shiftKey: ev.shiftKey
            });
        }
        onDocumentMouseUp_(ev) {
            const doc = this.elem_.ownerDocument;
            doc.removeEventListener('mousemove', this.onDocumentMouseMove_);
            doc.removeEventListener('mouseup', this.onDocumentMouseUp_);
            this.emitter.emit('up', {
                altKey: ev.altKey,
                data: this.computePosition_(computeOffset$1(ev, this.elem_)),
                sender: this,
                shiftKey: ev.shiftKey
            });
        }
        onTouchStart_(ev) {
            ev.preventDefault();
            const touch = ev.targetTouches.item(0);
            const rect = this.elem_.getBoundingClientRect();
            this.emitter.emit('down', {
                altKey: ev.altKey,
                data: this.computePosition_(touch ? {
                    x: touch.clientX - rect.left,
                    y: touch.clientY - rect.top
                } : undefined),
                sender: this,
                shiftKey: ev.shiftKey
            });
            this.lastTouch_ = touch;
        }
        onTouchMove_(ev) {
            const touch = ev.targetTouches.item(0);
            const rect = this.elem_.getBoundingClientRect();
            this.emitter.emit('move', {
                altKey: ev.altKey,
                data: this.computePosition_(touch ? {
                    x: touch.clientX - rect.left,
                    y: touch.clientY - rect.top
                } : undefined),
                sender: this,
                shiftKey: ev.shiftKey
            });
            this.lastTouch_ = touch;
        }
        onTouchEnd_(ev) {
            var _a;
            const touch = (_a = ev.targetTouches.item(0)) !== null && _a !== void 0 ? _a : this.lastTouch_;
            const rect = this.elem_.getBoundingClientRect();
            this.emitter.emit('up', {
                altKey: ev.altKey,
                data: this.computePosition_(touch ? {
                    x: touch.clientX - rect.left,
                    y: touch.clientY - rect.top
                } : undefined),
                sender: this,
                shiftKey: ev.shiftKey
            });
        }
    }
    function mapRange(value, start1, end1, start2, end2) {
        const p = (value - start1) / (end1 - start1);
        return start2 + p * (end2 - start2);
    }
    function getDecimalDigits(value) {
        const text = String(value.toFixed(10));
        const frac = text.split('.')[1];
        return frac.replace(/0+$/, '').length;
    }
    function constrainRange(value, min, max) {
        return Math.min(Math.max(value, min), max);
    }
    function loopRange(value, max) {
        return (value % max + max) % max;
    }
    const className$g = ClassName('txt');
    class NumberTextView {
        constructor(doc, config){
            this.onChange_ = this.onChange_.bind(this);
            this.props_ = config.props;
            this.props_.emitter.on('change', this.onChange_);
            this.element = doc.createElement('div');
            this.element.classList.add(className$g(), className$g(undefined, 'num'));
            if (config.arrayPosition) this.element.classList.add(className$g(undefined, config.arrayPosition));
            config.viewProps.bindClassModifiers(this.element);
            const inputElem = doc.createElement('input');
            inputElem.classList.add(className$g('i'));
            inputElem.type = 'text';
            config.viewProps.bindDisabled(inputElem);
            this.element.appendChild(inputElem);
            this.inputElement = inputElem;
            this.onDraggingChange_ = this.onDraggingChange_.bind(this);
            this.dragging_ = config.dragging;
            this.dragging_.emitter.on('change', this.onDraggingChange_);
            this.element.classList.add(className$g());
            this.inputElement.classList.add(className$g('i'));
            const knobElem = doc.createElement('div');
            knobElem.classList.add(className$g('k'));
            this.element.appendChild(knobElem);
            this.knobElement = knobElem;
            const guideElem = doc.createElementNS(SVG_NS, 'svg');
            guideElem.classList.add(className$g('g'));
            this.knobElement.appendChild(guideElem);
            const bodyElem = doc.createElementNS(SVG_NS, 'path');
            bodyElem.classList.add(className$g('gb'));
            guideElem.appendChild(bodyElem);
            this.guideBodyElem_ = bodyElem;
            const headElem = doc.createElementNS(SVG_NS, 'path');
            headElem.classList.add(className$g('gh'));
            guideElem.appendChild(headElem);
            this.guideHeadElem_ = headElem;
            const tooltipElem = doc.createElement('div');
            tooltipElem.classList.add(ClassName('tt')());
            this.knobElement.appendChild(tooltipElem);
            this.tooltipElem_ = tooltipElem;
            config.value.emitter.on('change', this.onChange_);
            this.value = config.value;
            this.refresh();
        }
        onDraggingChange_(ev) {
            if (ev.rawValue === null) {
                this.element.classList.remove(className$g(undefined, 'drg'));
                return;
            }
            this.element.classList.add(className$g(undefined, 'drg'));
            const x = ev.rawValue / this.props_.get('draggingScale');
            const aox = x + (x > 0 ? -1 : x < 0 ? 1 : 0);
            const adx = constrainRange(-aox, -4, 4);
            this.guideHeadElem_.setAttributeNS(null, 'd', [
                `M ${aox + adx},0 L${aox},4 L${aox + adx},8`,
                `M ${x},-1 L${x},9`
            ].join(' '));
            this.guideBodyElem_.setAttributeNS(null, 'd', `M 0,4 L${x},4`);
            const formatter = this.props_.get('formatter');
            this.tooltipElem_.textContent = formatter(this.value.rawValue);
            this.tooltipElem_.style.left = `${x}px`;
        }
        refresh() {
            const formatter = this.props_.get('formatter');
            this.inputElement.value = formatter(this.value.rawValue);
        }
        onChange_() {
            this.refresh();
        }
    }
    class NumberTextController {
        constructor(doc, config){
            var _a;
            this.originRawValue_ = 0;
            this.onInputChange_ = this.onInputChange_.bind(this);
            this.onInputKeyDown_ = this.onInputKeyDown_.bind(this);
            this.onInputKeyUp_ = this.onInputKeyUp_.bind(this);
            this.onPointerDown_ = this.onPointerDown_.bind(this);
            this.onPointerMove_ = this.onPointerMove_.bind(this);
            this.onPointerUp_ = this.onPointerUp_.bind(this);
            this.baseStep_ = config.baseStep;
            this.parser_ = config.parser;
            this.props = config.props;
            this.sliderProps_ = (_a = config.sliderProps) !== null && _a !== void 0 ? _a : null;
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.dragging_ = createValue(null);
            this.view = new NumberTextView(doc, {
                arrayPosition: config.arrayPosition,
                dragging: this.dragging_,
                props: this.props,
                value: this.value,
                viewProps: this.viewProps
            });
            this.view.inputElement.addEventListener('change', this.onInputChange_);
            this.view.inputElement.addEventListener('keydown', this.onInputKeyDown_);
            this.view.inputElement.addEventListener('keyup', this.onInputKeyUp_);
            const ph = new PointerHandler(this.view.knobElement);
            ph.emitter.on('down', this.onPointerDown_);
            ph.emitter.on('move', this.onPointerMove_);
            ph.emitter.on('up', this.onPointerUp_);
        }
        constrainValue_(value) {
            var _a, _b;
            const min = (_a = this.sliderProps_) === null || _a === void 0 ? void 0 : _a.get('minValue');
            const max = (_b = this.sliderProps_) === null || _b === void 0 ? void 0 : _b.get('maxValue');
            let v = value;
            if (min !== undefined) v = Math.max(v, min);
            if (max !== undefined) v = Math.min(v, max);
            return v;
        }
        onInputChange_(e) {
            const inputElem = forceCast(e.currentTarget);
            const value = inputElem.value;
            const parsedValue = this.parser_(value);
            if (!isEmpty(parsedValue)) this.value.rawValue = this.constrainValue_(parsedValue);
            this.view.refresh();
        }
        onInputKeyDown_(ev) {
            const step = getStepForKey(this.baseStep_, getVerticalStepKeys(ev));
            if (step === 0) return;
            this.value.setRawValue(this.constrainValue_(this.value.rawValue + step), {
                forceEmit: false,
                last: false
            });
        }
        onInputKeyUp_(ev) {
            const step = getStepForKey(this.baseStep_, getVerticalStepKeys(ev));
            if (step === 0) return;
            this.value.setRawValue(this.value.rawValue, {
                forceEmit: true,
                last: true
            });
        }
        onPointerDown_() {
            this.originRawValue_ = this.value.rawValue;
            this.dragging_.rawValue = 0;
        }
        computeDraggingValue_(data) {
            if (!data.point) return null;
            const dx = data.point.x - data.bounds.width / 2;
            return this.constrainValue_(this.originRawValue_ + dx * this.props.get('draggingScale'));
        }
        onPointerMove_(ev) {
            const v = this.computeDraggingValue_(ev.data);
            if (v === null) return;
            this.value.setRawValue(v, {
                forceEmit: false,
                last: false
            });
            this.dragging_.rawValue = this.value.rawValue - this.originRawValue_;
        }
        onPointerUp_(ev) {
            const v = this.computeDraggingValue_(ev.data);
            if (v === null) return;
            this.value.setRawValue(v, {
                forceEmit: true,
                last: true
            });
            this.dragging_.rawValue = null;
        }
    }
    const className$f = ClassName('sld');
    class SliderView {
        constructor(doc, config){
            this.onChange_ = this.onChange_.bind(this);
            this.props_ = config.props;
            this.props_.emitter.on('change', this.onChange_);
            this.element = doc.createElement('div');
            this.element.classList.add(className$f());
            config.viewProps.bindClassModifiers(this.element);
            const trackElem = doc.createElement('div');
            trackElem.classList.add(className$f('t'));
            config.viewProps.bindTabIndex(trackElem);
            this.element.appendChild(trackElem);
            this.trackElement = trackElem;
            const knobElem = doc.createElement('div');
            knobElem.classList.add(className$f('k'));
            this.trackElement.appendChild(knobElem);
            this.knobElement = knobElem;
            config.value.emitter.on('change', this.onChange_);
            this.value = config.value;
            this.update_();
        }
        update_() {
            const p = constrainRange(mapRange(this.value.rawValue, this.props_.get('minValue'), this.props_.get('maxValue'), 0, 100), 0, 100);
            this.knobElement.style.width = `${p}%`;
        }
        onChange_() {
            this.update_();
        }
    }
    class SliderController {
        constructor(doc, config){
            this.onKeyDown_ = this.onKeyDown_.bind(this);
            this.onKeyUp_ = this.onKeyUp_.bind(this);
            this.onPointerDownOrMove_ = this.onPointerDownOrMove_.bind(this);
            this.onPointerUp_ = this.onPointerUp_.bind(this);
            this.baseStep_ = config.baseStep;
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.props = config.props;
            this.view = new SliderView(doc, {
                props: this.props,
                value: this.value,
                viewProps: this.viewProps
            });
            this.ptHandler_ = new PointerHandler(this.view.trackElement);
            this.ptHandler_.emitter.on('down', this.onPointerDownOrMove_);
            this.ptHandler_.emitter.on('move', this.onPointerDownOrMove_);
            this.ptHandler_.emitter.on('up', this.onPointerUp_);
            this.view.trackElement.addEventListener('keydown', this.onKeyDown_);
            this.view.trackElement.addEventListener('keyup', this.onKeyUp_);
        }
        handlePointerEvent_(d, opts) {
            if (!d.point) return;
            this.value.setRawValue(mapRange(constrainRange(d.point.x, 0, d.bounds.width), 0, d.bounds.width, this.props.get('minValue'), this.props.get('maxValue')), opts);
        }
        onPointerDownOrMove_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerUp_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: true,
                last: true
            });
        }
        onKeyDown_(ev) {
            const step = getStepForKey(this.baseStep_, getHorizontalStepKeys(ev));
            if (step === 0) return;
            this.value.setRawValue(this.value.rawValue + step, {
                forceEmit: false,
                last: false
            });
        }
        onKeyUp_(ev) {
            const step = getStepForKey(this.baseStep_, getHorizontalStepKeys(ev));
            if (step === 0) return;
            this.value.setRawValue(this.value.rawValue, {
                forceEmit: true,
                last: true
            });
        }
    }
    const className$e = ClassName('sldtxt');
    class SliderTextView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$e());
            const sliderElem = doc.createElement('div');
            sliderElem.classList.add(className$e('s'));
            this.sliderView_ = config.sliderView;
            sliderElem.appendChild(this.sliderView_.element);
            this.element.appendChild(sliderElem);
            const textElem = doc.createElement('div');
            textElem.classList.add(className$e('t'));
            this.textView_ = config.textView;
            textElem.appendChild(this.textView_.element);
            this.element.appendChild(textElem);
        }
    }
    class SliderTextController {
        constructor(doc, config){
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.sliderC_ = new SliderController(doc, {
                baseStep: config.baseStep,
                props: config.sliderProps,
                value: config.value,
                viewProps: this.viewProps
            });
            this.textC_ = new NumberTextController(doc, {
                baseStep: config.baseStep,
                parser: config.parser,
                props: config.textProps,
                sliderProps: config.sliderProps,
                value: config.value,
                viewProps: config.viewProps
            });
            this.view = new SliderTextView(doc, {
                sliderView: this.sliderC_.view,
                textView: this.textC_.view
            });
        }
        get sliderController() {
            return this.sliderC_;
        }
        get textController() {
            return this.textC_;
        }
    }
    function writePrimitive(target, value) {
        target.write(value);
    }
    function parseListOptions(value) {
        const p = ParamsParsers;
        if (Array.isArray(value)) return p.required.array(p.required.object({
            text: p.required.string,
            value: p.required.raw
        }))(value).value;
        if (typeof value === 'object') return p.required.raw(value).value;
        return undefined;
    }
    function parsePickerLayout(value) {
        if (value === 'inline' || value === 'popup') return value;
        return undefined;
    }
    function parsePointDimensionParams(value) {
        const p = ParamsParsers;
        return p.required.object({
            max: p.optional.number,
            min: p.optional.number,
            step: p.optional.number
        })(value).value;
    }
    function normalizeListOptions(options) {
        if (Array.isArray(options)) return options;
        const items = [];
        Object.keys(options).forEach((text)=>{
            items.push({
                text: text,
                value: options[text]
            });
        });
        return items;
    }
    function createListConstraint(options) {
        return !isEmpty(options) ? new ListConstraint(normalizeListOptions(forceCast(options))) : null;
    }
    function findStep(constraint) {
        const c = constraint ? findConstraint(constraint, StepConstraint) : null;
        if (!c) return null;
        return c.step;
    }
    function getSuitableDecimalDigits(constraint, rawValue) {
        const sc = constraint && findConstraint(constraint, StepConstraint);
        if (sc) return getDecimalDigits(sc.step);
        return Math.max(getDecimalDigits(rawValue), 2);
    }
    function getBaseStep(constraint) {
        const step = findStep(constraint);
        return step !== null && step !== void 0 ? step : 1;
    }
    function getSuitableDraggingScale(constraint, rawValue) {
        var _a;
        const sc = constraint && findConstraint(constraint, StepConstraint);
        const base = Math.abs((_a = sc === null || sc === void 0 ? void 0 : sc.step) !== null && _a !== void 0 ? _a : rawValue);
        return base === 0 ? 0.1 : Math.pow(10, Math.floor(Math.log10(base)) - 1);
    }
    const className$d = ClassName('ckb');
    class CheckboxView {
        constructor(doc, config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.element = doc.createElement('div');
            this.element.classList.add(className$d());
            config.viewProps.bindClassModifiers(this.element);
            const labelElem = doc.createElement('label');
            labelElem.classList.add(className$d('l'));
            this.element.appendChild(labelElem);
            const inputElem = doc.createElement('input');
            inputElem.classList.add(className$d('i'));
            inputElem.type = 'checkbox';
            labelElem.appendChild(inputElem);
            this.inputElement = inputElem;
            config.viewProps.bindDisabled(this.inputElement);
            const wrapperElem = doc.createElement('div');
            wrapperElem.classList.add(className$d('w'));
            labelElem.appendChild(wrapperElem);
            const markElem = createSvgIconElement(doc, 'check');
            wrapperElem.appendChild(markElem);
            config.value.emitter.on('change', this.onValueChange_);
            this.value = config.value;
            this.update_();
        }
        update_() {
            this.inputElement.checked = this.value.rawValue;
        }
        onValueChange_() {
            this.update_();
        }
    }
    class CheckboxController {
        constructor(doc, config){
            this.onInputChange_ = this.onInputChange_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new CheckboxView(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            this.view.inputElement.addEventListener('change', this.onInputChange_);
        }
        onInputChange_(e) {
            const inputElem = forceCast(e.currentTarget);
            this.value.rawValue = inputElem.checked;
        }
    }
    function createConstraint$6(params) {
        const constraints = [];
        const lc = createListConstraint(params.options);
        if (lc) constraints.push(lc);
        return new CompositeConstraint(constraints);
    }
    const BooleanInputPlugin = {
        id: 'input-bool',
        type: 'input',
        accept: (value, params)=>{
            if (typeof value !== 'boolean') return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                options: p.optional.custom(parseListOptions)
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>boolFromUnknown,
            constraint: (args)=>createConstraint$6(args.params),
            writer: (_args)=>writePrimitive
        },
        controller: (args)=>{
            const doc = args.document;
            const value = args.value;
            const c = args.constraint;
            const lc = c && findConstraint(c, ListConstraint);
            if (lc) return new ListController(doc, {
                props: new ValueMap({
                    options: lc.values.value('options')
                }),
                value: value,
                viewProps: args.viewProps
            });
            return new CheckboxController(doc, {
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    const className$c = ClassName('col');
    class ColorView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$c());
            config.foldable.bindExpandedClass(this.element, className$c(undefined, 'expanded'));
            bindValueMap(config.foldable, 'completed', valueToClassName(this.element, className$c(undefined, 'cpl')));
            const headElem = doc.createElement('div');
            headElem.classList.add(className$c('h'));
            this.element.appendChild(headElem);
            const swatchElem = doc.createElement('div');
            swatchElem.classList.add(className$c('s'));
            headElem.appendChild(swatchElem);
            this.swatchElement = swatchElem;
            const textElem = doc.createElement('div');
            textElem.classList.add(className$c('t'));
            headElem.appendChild(textElem);
            this.textElement = textElem;
            if (config.pickerLayout === 'inline') {
                const pickerElem = doc.createElement('div');
                pickerElem.classList.add(className$c('p'));
                this.element.appendChild(pickerElem);
                this.pickerElement = pickerElem;
            } else this.pickerElement = null;
        }
    }
    function rgbToHslInt(r, g, b) {
        const rp = constrainRange(r / 255, 0, 1);
        const gp = constrainRange(g / 255, 0, 1);
        const bp = constrainRange(b / 255, 0, 1);
        const cmax = Math.max(rp, gp, bp);
        const cmin = Math.min(rp, gp, bp);
        const c = cmax - cmin;
        let h = 0;
        let s = 0;
        const l = (cmin + cmax) / 2;
        if (c !== 0) {
            s = c / (1 - Math.abs(cmax + cmin - 1));
            if (rp === cmax) h = (gp - bp) / c;
            else if (gp === cmax) h = 2 + (bp - rp) / c;
            else h = 4 + (rp - gp) / c;
            h = h / 6 + (h < 0 ? 1 : 0);
        }
        return [
            h * 360,
            s * 100,
            l * 100
        ];
    }
    function hslToRgbInt(h, s, l) {
        const hp = (h % 360 + 360) % 360;
        const sp = constrainRange(s / 100, 0, 1);
        const lp = constrainRange(l / 100, 0, 1);
        const c = (1 - Math.abs(2 * lp - 1)) * sp;
        const x = c * (1 - Math.abs(hp / 60 % 2 - 1));
        const m = lp - c / 2;
        let rp, gp, bp;
        if (hp >= 0 && hp < 60) [rp, gp, bp] = [
            c,
            x,
            0
        ];
        else if (hp >= 60 && hp < 120) [rp, gp, bp] = [
            x,
            c,
            0
        ];
        else if (hp >= 120 && hp < 180) [rp, gp, bp] = [
            0,
            c,
            x
        ];
        else if (hp >= 180 && hp < 240) [rp, gp, bp] = [
            0,
            x,
            c
        ];
        else if (hp >= 240 && hp < 300) [rp, gp, bp] = [
            x,
            0,
            c
        ];
        else [rp, gp, bp] = [
            c,
            0,
            x
        ];
        return [
            (rp + m) * 255,
            (gp + m) * 255,
            (bp + m) * 255
        ];
    }
    function rgbToHsvInt(r, g, b) {
        const rp = constrainRange(r / 255, 0, 1);
        const gp = constrainRange(g / 255, 0, 1);
        const bp = constrainRange(b / 255, 0, 1);
        const cmax = Math.max(rp, gp, bp);
        const cmin = Math.min(rp, gp, bp);
        const d = cmax - cmin;
        let h;
        if (d === 0) h = 0;
        else if (cmax === rp) h = 60 * (((gp - bp) / d % 6 + 6) % 6);
        else if (cmax === gp) h = 60 * ((bp - rp) / d + 2);
        else h = 60 * ((rp - gp) / d + 4);
        const s = cmax === 0 ? 0 : d / cmax;
        const v = cmax;
        return [
            h,
            s * 100,
            v * 100
        ];
    }
    function hsvToRgbInt(h, s, v) {
        const hp = loopRange(h, 360);
        const sp = constrainRange(s / 100, 0, 1);
        const vp = constrainRange(v / 100, 0, 1);
        const c = vp * sp;
        const x = c * (1 - Math.abs(hp / 60 % 2 - 1));
        const m = vp - c;
        let rp, gp, bp;
        if (hp >= 0 && hp < 60) [rp, gp, bp] = [
            c,
            x,
            0
        ];
        else if (hp >= 60 && hp < 120) [rp, gp, bp] = [
            x,
            c,
            0
        ];
        else if (hp >= 120 && hp < 180) [rp, gp, bp] = [
            0,
            c,
            x
        ];
        else if (hp >= 180 && hp < 240) [rp, gp, bp] = [
            0,
            x,
            c
        ];
        else if (hp >= 240 && hp < 300) [rp, gp, bp] = [
            x,
            0,
            c
        ];
        else [rp, gp, bp] = [
            c,
            0,
            x
        ];
        return [
            (rp + m) * 255,
            (gp + m) * 255,
            (bp + m) * 255
        ];
    }
    function hslToHsvInt(h, s, l) {
        const sd = l + s * (100 - Math.abs(2 * l - 100)) / 200;
        return [
            h,
            sd !== 0 ? s * (100 - Math.abs(2 * l - 100)) / sd : 0,
            l + s * (100 - Math.abs(2 * l - 100)) / 200
        ];
    }
    function hsvToHslInt(h, s, v) {
        const sd = 100 - Math.abs(v * (200 - s) / 100 - 100);
        return [
            h,
            sd !== 0 ? s * v / sd : 0,
            v * (200 - s) / 200
        ];
    }
    function removeAlphaComponent(comps) {
        return [
            comps[0],
            comps[1],
            comps[2]
        ];
    }
    function appendAlphaComponent(comps, alpha) {
        return [
            comps[0],
            comps[1],
            comps[2],
            alpha
        ];
    }
    const MODE_CONVERTER_MAP = {
        hsl: {
            hsl: (h, s, l)=>[
                    h,
                    s,
                    l
                ],
            hsv: hslToHsvInt,
            rgb: hslToRgbInt
        },
        hsv: {
            hsl: hsvToHslInt,
            hsv: (h, s, v)=>[
                    h,
                    s,
                    v
                ],
            rgb: hsvToRgbInt
        },
        rgb: {
            hsl: rgbToHslInt,
            hsv: rgbToHsvInt,
            rgb: (r, g, b)=>[
                    r,
                    g,
                    b
                ]
        }
    };
    function getColorMaxComponents(mode, type) {
        return [
            type === 'float' ? 1 : mode === 'rgb' ? 255 : 360,
            type === 'float' ? 1 : mode === 'rgb' ? 255 : 100,
            type === 'float' ? 1 : mode === 'rgb' ? 255 : 100
        ];
    }
    function loopHueRange(hue, max) {
        return hue === max ? max : loopRange(hue, max);
    }
    function constrainColorComponents(components, mode, type) {
        var _a;
        const ms = getColorMaxComponents(mode, type);
        return [
            mode === 'rgb' ? constrainRange(components[0], 0, ms[0]) : loopHueRange(components[0], ms[0]),
            constrainRange(components[1], 0, ms[1]),
            constrainRange(components[2], 0, ms[2]),
            constrainRange((_a = components[3]) !== null && _a !== void 0 ? _a : 1, 0, 1)
        ];
    }
    function convertColorType(comps, mode, from, to) {
        const fms = getColorMaxComponents(mode, from);
        const tms = getColorMaxComponents(mode, to);
        return comps.map((c, index)=>c / fms[index] * tms[index]);
    }
    function convertColor(components, from, to) {
        const intComps = convertColorType(components, from.mode, from.type, 'int');
        const result = MODE_CONVERTER_MAP[from.mode][to.mode](...intComps);
        return convertColorType(result, to.mode, 'int', to.type);
    }
    function isRgbColorComponent(obj, key) {
        if (typeof obj !== 'object' || isEmpty(obj)) return false;
        return key in obj && typeof obj[key] === 'number';
    }
    class Color {
        static black(type = 'int') {
            return new Color([
                0,
                0,
                0
            ], 'rgb', type);
        }
        static fromObject(obj, type = 'int') {
            const comps = 'a' in obj ? [
                obj.r,
                obj.g,
                obj.b,
                obj.a
            ] : [
                obj.r,
                obj.g,
                obj.b
            ];
            return new Color(comps, 'rgb', type);
        }
        static toRgbaObject(color, type = 'int') {
            return color.toRgbaObject(type);
        }
        static isRgbColorObject(obj) {
            return isRgbColorComponent(obj, 'r') && isRgbColorComponent(obj, 'g') && isRgbColorComponent(obj, 'b');
        }
        static isRgbaColorObject(obj) {
            return this.isRgbColorObject(obj) && isRgbColorComponent(obj, 'a');
        }
        static isColorObject(obj) {
            return this.isRgbColorObject(obj);
        }
        static equals(v1, v2) {
            if (v1.mode !== v2.mode) return false;
            const comps1 = v1.comps_;
            const comps2 = v2.comps_;
            for(let i = 0; i < comps1.length; i++){
                if (comps1[i] !== comps2[i]) return false;
            }
            return true;
        }
        constructor(comps, mode, type = 'int'){
            this.mode = mode;
            this.type = type;
            this.comps_ = constrainColorComponents(comps, mode, type);
        }
        getComponents(opt_mode, type = 'int') {
            return appendAlphaComponent(convertColor(removeAlphaComponent(this.comps_), {
                mode: this.mode,
                type: this.type
            }, {
                mode: opt_mode !== null && opt_mode !== void 0 ? opt_mode : this.mode,
                type: type
            }), this.comps_[3]);
        }
        toRgbaObject(type = 'int') {
            const rgbComps = this.getComponents('rgb', type);
            return {
                r: rgbComps[0],
                g: rgbComps[1],
                b: rgbComps[2],
                a: rgbComps[3]
            };
        }
    }
    const className$b = ClassName('colp');
    class ColorPickerView {
        constructor(doc, config){
            this.alphaViews_ = null;
            this.element = doc.createElement('div');
            this.element.classList.add(className$b());
            config.viewProps.bindClassModifiers(this.element);
            const hsvElem = doc.createElement('div');
            hsvElem.classList.add(className$b('hsv'));
            const svElem = doc.createElement('div');
            svElem.classList.add(className$b('sv'));
            this.svPaletteView_ = config.svPaletteView;
            svElem.appendChild(this.svPaletteView_.element);
            hsvElem.appendChild(svElem);
            const hElem = doc.createElement('div');
            hElem.classList.add(className$b('h'));
            this.hPaletteView_ = config.hPaletteView;
            hElem.appendChild(this.hPaletteView_.element);
            hsvElem.appendChild(hElem);
            this.element.appendChild(hsvElem);
            const rgbElem = doc.createElement('div');
            rgbElem.classList.add(className$b('rgb'));
            this.textView_ = config.textView;
            rgbElem.appendChild(this.textView_.element);
            this.element.appendChild(rgbElem);
            if (config.alphaViews) {
                this.alphaViews_ = {
                    palette: config.alphaViews.palette,
                    text: config.alphaViews.text
                };
                const aElem = doc.createElement('div');
                aElem.classList.add(className$b('a'));
                const apElem = doc.createElement('div');
                apElem.classList.add(className$b('ap'));
                apElem.appendChild(this.alphaViews_.palette.element);
                aElem.appendChild(apElem);
                const atElem = doc.createElement('div');
                atElem.classList.add(className$b('at'));
                atElem.appendChild(this.alphaViews_.text.element);
                aElem.appendChild(atElem);
                this.element.appendChild(aElem);
            }
        }
        get allFocusableElements() {
            const elems = [
                this.svPaletteView_.element,
                this.hPaletteView_.element,
                this.textView_.modeSelectElement,
                ...this.textView_.textViews.map((v)=>v.inputElement)
            ];
            if (this.alphaViews_) elems.push(this.alphaViews_.palette.element, this.alphaViews_.text.inputElement);
            return elems;
        }
    }
    function parseColorType(value) {
        return value === 'int' ? 'int' : value === 'float' ? 'float' : undefined;
    }
    function parseColorInputParams(params) {
        const p = ParamsParsers;
        return parseParams(params, {
            alpha: p.optional.boolean,
            color: p.optional.object({
                alpha: p.optional.boolean,
                type: p.optional.custom(parseColorType)
            }),
            expanded: p.optional.boolean,
            picker: p.optional.custom(parsePickerLayout)
        });
    }
    function getBaseStepForColor(forAlpha) {
        return forAlpha ? 0.1 : 1;
    }
    function extractColorType(params) {
        var _a;
        return (_a = params.color) === null || _a === void 0 ? void 0 : _a.type;
    }
    function equalsStringColorFormat(f1, f2) {
        return f1.alpha === f2.alpha && f1.mode === f2.mode && f1.notation === f2.notation && f1.type === f2.type;
    }
    function parseCssNumberOrPercentage(text, maxValue) {
        const m = text.match(/^(.+)%$/);
        if (!m) return Math.min(parseFloat(text), maxValue);
        return Math.min(parseFloat(m[1]) * 0.01 * maxValue, maxValue);
    }
    const ANGLE_TO_DEG_MAP = {
        deg: (angle)=>angle,
        grad: (angle)=>angle * 360 / 400,
        rad: (angle)=>angle * 360 / (2 * Math.PI),
        turn: (angle)=>angle * 360
    };
    function parseCssNumberOrAngle(text) {
        const m = text.match(/^([0-9.]+?)(deg|grad|rad|turn)$/);
        if (!m) return parseFloat(text);
        const angle = parseFloat(m[1]);
        const unit = m[2];
        return ANGLE_TO_DEG_MAP[unit](angle);
    }
    function parseFunctionalRgbColorComponents(text) {
        const m = text.match(/^rgb\(\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*\)$/);
        if (!m) return null;
        const comps = [
            parseCssNumberOrPercentage(m[1], 255),
            parseCssNumberOrPercentage(m[2], 255),
            parseCssNumberOrPercentage(m[3], 255)
        ];
        if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2])) return null;
        return comps;
    }
    function createFunctionalRgbColorParser(type) {
        return (text)=>{
            const comps = parseFunctionalRgbColorComponents(text);
            return comps ? new Color(comps, 'rgb', type) : null;
        };
    }
    function parseFunctionalRgbaColorComponents(text) {
        const m = text.match(/^rgba\(\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*\)$/);
        if (!m) return null;
        const comps = [
            parseCssNumberOrPercentage(m[1], 255),
            parseCssNumberOrPercentage(m[2], 255),
            parseCssNumberOrPercentage(m[3], 255),
            parseCssNumberOrPercentage(m[4], 1)
        ];
        if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2]) || isNaN(comps[3])) return null;
        return comps;
    }
    function createFunctionalRgbaColorParser(type) {
        return (text)=>{
            const comps = parseFunctionalRgbaColorComponents(text);
            return comps ? new Color(comps, 'rgb', type) : null;
        };
    }
    function parseHslColorComponents(text) {
        const m = text.match(/^hsl\(\s*([0-9A-Fa-f.]+(?:deg|grad|rad|turn)?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*\)$/);
        if (!m) return null;
        const comps = [
            parseCssNumberOrAngle(m[1]),
            parseCssNumberOrPercentage(m[2], 100),
            parseCssNumberOrPercentage(m[3], 100)
        ];
        if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2])) return null;
        return comps;
    }
    function createHslColorParser(type) {
        return (text)=>{
            const comps = parseHslColorComponents(text);
            return comps ? new Color(comps, 'hsl', type) : null;
        };
    }
    function parseHslaColorComponents(text) {
        const m = text.match(/^hsla\(\s*([0-9A-Fa-f.]+(?:deg|grad|rad|turn)?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*,\s*([0-9A-Fa-f.]+%?)\s*\)$/);
        if (!m) return null;
        const comps = [
            parseCssNumberOrAngle(m[1]),
            parseCssNumberOrPercentage(m[2], 100),
            parseCssNumberOrPercentage(m[3], 100),
            parseCssNumberOrPercentage(m[4], 1)
        ];
        if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2]) || isNaN(comps[3])) return null;
        return comps;
    }
    function createHslaColorParser(type) {
        return (text)=>{
            const comps = parseHslaColorComponents(text);
            return comps ? new Color(comps, 'hsl', type) : null;
        };
    }
    function parseHexRgbColorComponents(text) {
        const mRgb = text.match(/^#([0-9A-Fa-f])([0-9A-Fa-f])([0-9A-Fa-f])$/);
        if (mRgb) return [
            parseInt(mRgb[1] + mRgb[1], 16),
            parseInt(mRgb[2] + mRgb[2], 16),
            parseInt(mRgb[3] + mRgb[3], 16)
        ];
        const mRrggbb = text.match(/^(?:#|0x)([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/);
        if (mRrggbb) return [
            parseInt(mRrggbb[1], 16),
            parseInt(mRrggbb[2], 16),
            parseInt(mRrggbb[3], 16)
        ];
        return null;
    }
    function parseHexRgbColor(text) {
        const comps = parseHexRgbColorComponents(text);
        return comps ? new Color(comps, 'rgb', 'int') : null;
    }
    function parseHexRgbaColorComponents(text) {
        const mRgb = text.match(/^#?([0-9A-Fa-f])([0-9A-Fa-f])([0-9A-Fa-f])([0-9A-Fa-f])$/);
        if (mRgb) return [
            parseInt(mRgb[1] + mRgb[1], 16),
            parseInt(mRgb[2] + mRgb[2], 16),
            parseInt(mRgb[3] + mRgb[3], 16),
            mapRange(parseInt(mRgb[4] + mRgb[4], 16), 0, 255, 0, 1)
        ];
        const mRrggbb = text.match(/^(?:#|0x)?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/);
        if (mRrggbb) return [
            parseInt(mRrggbb[1], 16),
            parseInt(mRrggbb[2], 16),
            parseInt(mRrggbb[3], 16),
            mapRange(parseInt(mRrggbb[4], 16), 0, 255, 0, 1)
        ];
        return null;
    }
    function parseHexRgbaColor(text) {
        const comps = parseHexRgbaColorComponents(text);
        return comps ? new Color(comps, 'rgb', 'int') : null;
    }
    function parseObjectRgbColorComponents(text) {
        const m = text.match(/^\{\s*r\s*:\s*([0-9A-Fa-f.]+%?)\s*,\s*g\s*:\s*([0-9A-Fa-f.]+%?)\s*,\s*b\s*:\s*([0-9A-Fa-f.]+%?)\s*\}$/);
        if (!m) return null;
        const comps = [
            parseFloat(m[1]),
            parseFloat(m[2]),
            parseFloat(m[3])
        ];
        if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2])) return null;
        return comps;
    }
    function createObjectRgbColorParser(type) {
        return (text)=>{
            const comps = parseObjectRgbColorComponents(text);
            return comps ? new Color(comps, 'rgb', type) : null;
        };
    }
    function parseObjectRgbaColorComponents(text) {
        const m = text.match(/^\{\s*r\s*:\s*([0-9A-Fa-f.]+%?)\s*,\s*g\s*:\s*([0-9A-Fa-f.]+%?)\s*,\s*b\s*:\s*([0-9A-Fa-f.]+%?)\s*,\s*a\s*:\s*([0-9A-Fa-f.]+%?)\s*\}$/);
        if (!m) return null;
        const comps = [
            parseFloat(m[1]),
            parseFloat(m[2]),
            parseFloat(m[3]),
            parseFloat(m[4])
        ];
        if (isNaN(comps[0]) || isNaN(comps[1]) || isNaN(comps[2]) || isNaN(comps[3])) return null;
        return comps;
    }
    function createObjectRgbaColorParser(type) {
        return (text)=>{
            const comps = parseObjectRgbaColorComponents(text);
            return comps ? new Color(comps, 'rgb', type) : null;
        };
    }
    const PARSER_AND_RESULT = [
        {
            parser: parseHexRgbColorComponents,
            result: {
                alpha: false,
                mode: 'rgb',
                notation: 'hex'
            }
        },
        {
            parser: parseHexRgbaColorComponents,
            result: {
                alpha: true,
                mode: 'rgb',
                notation: 'hex'
            }
        },
        {
            parser: parseFunctionalRgbColorComponents,
            result: {
                alpha: false,
                mode: 'rgb',
                notation: 'func'
            }
        },
        {
            parser: parseFunctionalRgbaColorComponents,
            result: {
                alpha: true,
                mode: 'rgb',
                notation: 'func'
            }
        },
        {
            parser: parseHslColorComponents,
            result: {
                alpha: false,
                mode: 'hsl',
                notation: 'func'
            }
        },
        {
            parser: parseHslaColorComponents,
            result: {
                alpha: true,
                mode: 'hsl',
                notation: 'func'
            }
        },
        {
            parser: parseObjectRgbColorComponents,
            result: {
                alpha: false,
                mode: 'rgb',
                notation: 'object'
            }
        },
        {
            parser: parseObjectRgbaColorComponents,
            result: {
                alpha: true,
                mode: 'rgb',
                notation: 'object'
            }
        }
    ];
    function detectStringColor(text) {
        return PARSER_AND_RESULT.reduce((prev, { parser: parser, result: detection })=>{
            if (prev) return prev;
            return parser(text) ? detection : null;
        }, null);
    }
    function detectStringColorFormat(text, type = 'int') {
        const r = detectStringColor(text);
        if (!r) return null;
        if (r.notation === 'hex' && type !== 'float') return Object.assign(Object.assign({}, r), {
            type: 'int'
        });
        if (r.notation === 'func') return Object.assign(Object.assign({}, r), {
            type: type
        });
        return null;
    }
    const TYPE_TO_PARSERS = {
        int: [
            parseHexRgbColor,
            parseHexRgbaColor,
            createFunctionalRgbColorParser('int'),
            createFunctionalRgbaColorParser('int'),
            createHslColorParser('int'),
            createHslaColorParser('int'),
            createObjectRgbColorParser('int'),
            createObjectRgbaColorParser('int')
        ],
        float: [
            createFunctionalRgbColorParser('float'),
            createFunctionalRgbaColorParser('float'),
            createHslColorParser('float'),
            createHslaColorParser('float'),
            createObjectRgbColorParser('float'),
            createObjectRgbaColorParser('float')
        ]
    };
    function createColorStringBindingReader(type) {
        const parsers = TYPE_TO_PARSERS[type];
        return (value)=>{
            if (typeof value !== 'string') return Color.black(type);
            const result = parsers.reduce((prev, parser)=>{
                if (prev) return prev;
                return parser(value);
            }, null);
            return result !== null && result !== void 0 ? result : Color.black(type);
        };
    }
    function createColorStringParser(type) {
        const parsers = TYPE_TO_PARSERS[type];
        return (value)=>{
            return parsers.reduce((prev, parser)=>{
                if (prev) return prev;
                return parser(value);
            }, null);
        };
    }
    function zerofill(comp) {
        const hex = constrainRange(Math.floor(comp), 0, 255).toString(16);
        return hex.length === 1 ? `0${hex}` : hex;
    }
    function colorToHexRgbString(value, prefix = '#') {
        const hexes = removeAlphaComponent(value.getComponents('rgb')).map(zerofill).join('');
        return `${prefix}${hexes}`;
    }
    function colorToHexRgbaString(value, prefix = '#') {
        const rgbaComps = value.getComponents('rgb');
        const hexes = [
            rgbaComps[0],
            rgbaComps[1],
            rgbaComps[2],
            rgbaComps[3] * 255
        ].map(zerofill).join('');
        return `${prefix}${hexes}`;
    }
    function colorToFunctionalRgbString(value, opt_type) {
        const formatter = createNumberFormatter(opt_type === 'float' ? 2 : 0);
        const comps = removeAlphaComponent(value.getComponents('rgb', opt_type)).map((comp)=>formatter(comp));
        return `rgb(${comps.join(', ')})`;
    }
    function createFunctionalRgbColorFormatter(type) {
        return (value)=>{
            return colorToFunctionalRgbString(value, type);
        };
    }
    function colorToFunctionalRgbaString(value, opt_type) {
        const aFormatter = createNumberFormatter(2);
        const rgbFormatter = createNumberFormatter(opt_type === 'float' ? 2 : 0);
        const comps = value.getComponents('rgb', opt_type).map((comp, index)=>{
            const formatter = index === 3 ? aFormatter : rgbFormatter;
            return formatter(comp);
        });
        return `rgba(${comps.join(', ')})`;
    }
    function createFunctionalRgbaColorFormatter(type) {
        return (value)=>{
            return colorToFunctionalRgbaString(value, type);
        };
    }
    function colorToFunctionalHslString(value) {
        const formatters = [
            createNumberFormatter(0),
            formatPercentage,
            formatPercentage
        ];
        const comps = removeAlphaComponent(value.getComponents('hsl')).map((comp, index)=>formatters[index](comp));
        return `hsl(${comps.join(', ')})`;
    }
    function colorToFunctionalHslaString(value) {
        const formatters = [
            createNumberFormatter(0),
            formatPercentage,
            formatPercentage,
            createNumberFormatter(2)
        ];
        const comps = value.getComponents('hsl').map((comp, index)=>formatters[index](comp));
        return `hsla(${comps.join(', ')})`;
    }
    function colorToObjectRgbString(value, type) {
        const formatter = createNumberFormatter(type === 'float' ? 2 : 0);
        const names = [
            'r',
            'g',
            'b'
        ];
        const comps = removeAlphaComponent(value.getComponents('rgb', type)).map((comp, index)=>`${names[index]}: ${formatter(comp)}`);
        return `{${comps.join(', ')}}`;
    }
    function createObjectRgbColorFormatter(type) {
        return (value)=>colorToObjectRgbString(value, type);
    }
    function colorToObjectRgbaString(value, type) {
        const aFormatter = createNumberFormatter(2);
        const rgbFormatter = createNumberFormatter(type === 'float' ? 2 : 0);
        const names = [
            'r',
            'g',
            'b',
            'a'
        ];
        const comps = value.getComponents('rgb', type).map((comp, index)=>{
            const formatter = index === 3 ? aFormatter : rgbFormatter;
            return `${names[index]}: ${formatter(comp)}`;
        });
        return `{${comps.join(', ')}}`;
    }
    function createObjectRgbaColorFormatter(type) {
        return (value)=>colorToObjectRgbaString(value, type);
    }
    const FORMAT_AND_STRINGIFIERS = [
        {
            format: {
                alpha: false,
                mode: 'rgb',
                notation: 'hex',
                type: 'int'
            },
            stringifier: colorToHexRgbString
        },
        {
            format: {
                alpha: true,
                mode: 'rgb',
                notation: 'hex',
                type: 'int'
            },
            stringifier: colorToHexRgbaString
        },
        {
            format: {
                alpha: false,
                mode: 'hsl',
                notation: 'func',
                type: 'int'
            },
            stringifier: colorToFunctionalHslString
        },
        {
            format: {
                alpha: true,
                mode: 'hsl',
                notation: 'func',
                type: 'int'
            },
            stringifier: colorToFunctionalHslaString
        },
        ...[
            'int',
            'float'
        ].reduce((prev, type)=>{
            return [
                ...prev,
                {
                    format: {
                        alpha: false,
                        mode: 'rgb',
                        notation: 'func',
                        type: type
                    },
                    stringifier: createFunctionalRgbColorFormatter(type)
                },
                {
                    format: {
                        alpha: true,
                        mode: 'rgb',
                        notation: 'func',
                        type: type
                    },
                    stringifier: createFunctionalRgbaColorFormatter(type)
                },
                {
                    format: {
                        alpha: false,
                        mode: 'rgb',
                        notation: 'object',
                        type: type
                    },
                    stringifier: createObjectRgbColorFormatter(type)
                },
                {
                    format: {
                        alpha: true,
                        mode: 'rgb',
                        notation: 'object',
                        type: type
                    },
                    stringifier: createObjectRgbaColorFormatter(type)
                }
            ];
        }, [])
    ];
    function findColorStringifier(format) {
        return FORMAT_AND_STRINGIFIERS.reduce((prev, fas)=>{
            if (prev) return prev;
            return equalsStringColorFormat(fas.format, format) ? fas.stringifier : null;
        }, null);
    }
    const className$a = ClassName('apl');
    class APaletteView {
        constructor(doc, config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.value = config.value;
            this.value.emitter.on('change', this.onValueChange_);
            this.element = doc.createElement('div');
            this.element.classList.add(className$a());
            config.viewProps.bindClassModifiers(this.element);
            config.viewProps.bindTabIndex(this.element);
            const barElem = doc.createElement('div');
            barElem.classList.add(className$a('b'));
            this.element.appendChild(barElem);
            const colorElem = doc.createElement('div');
            colorElem.classList.add(className$a('c'));
            barElem.appendChild(colorElem);
            this.colorElem_ = colorElem;
            const markerElem = doc.createElement('div');
            markerElem.classList.add(className$a('m'));
            this.element.appendChild(markerElem);
            this.markerElem_ = markerElem;
            const previewElem = doc.createElement('div');
            previewElem.classList.add(className$a('p'));
            this.markerElem_.appendChild(previewElem);
            this.previewElem_ = previewElem;
            this.update_();
        }
        update_() {
            const c = this.value.rawValue;
            const rgbaComps = c.getComponents('rgb');
            const leftColor = new Color([
                rgbaComps[0],
                rgbaComps[1],
                rgbaComps[2],
                0
            ], 'rgb');
            const rightColor = new Color([
                rgbaComps[0],
                rgbaComps[1],
                rgbaComps[2],
                255
            ], 'rgb');
            const gradientComps = [
                'to right',
                colorToFunctionalRgbaString(leftColor),
                colorToFunctionalRgbaString(rightColor)
            ];
            this.colorElem_.style.background = `linear-gradient(${gradientComps.join(',')})`;
            this.previewElem_.style.backgroundColor = colorToFunctionalRgbaString(c);
            const left = mapRange(rgbaComps[3], 0, 1, 0, 100);
            this.markerElem_.style.left = `${left}%`;
        }
        onValueChange_() {
            this.update_();
        }
    }
    class APaletteController {
        constructor(doc, config){
            this.onKeyDown_ = this.onKeyDown_.bind(this);
            this.onKeyUp_ = this.onKeyUp_.bind(this);
            this.onPointerDown_ = this.onPointerDown_.bind(this);
            this.onPointerMove_ = this.onPointerMove_.bind(this);
            this.onPointerUp_ = this.onPointerUp_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new APaletteView(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            this.ptHandler_ = new PointerHandler(this.view.element);
            this.ptHandler_.emitter.on('down', this.onPointerDown_);
            this.ptHandler_.emitter.on('move', this.onPointerMove_);
            this.ptHandler_.emitter.on('up', this.onPointerUp_);
            this.view.element.addEventListener('keydown', this.onKeyDown_);
            this.view.element.addEventListener('keyup', this.onKeyUp_);
        }
        handlePointerEvent_(d, opts) {
            if (!d.point) return;
            const alpha = d.point.x / d.bounds.width;
            const c = this.value.rawValue;
            const [h, s, v] = c.getComponents('hsv');
            this.value.setRawValue(new Color([
                h,
                s,
                v,
                alpha
            ], 'hsv'), opts);
        }
        onPointerDown_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerMove_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerUp_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: true,
                last: true
            });
        }
        onKeyDown_(ev) {
            const step = getStepForKey(getBaseStepForColor(true), getHorizontalStepKeys(ev));
            if (step === 0) return;
            const c = this.value.rawValue;
            const [h, s, v, a] = c.getComponents('hsv');
            this.value.setRawValue(new Color([
                h,
                s,
                v,
                a + step
            ], 'hsv'), {
                forceEmit: false,
                last: false
            });
        }
        onKeyUp_(ev) {
            const step = getStepForKey(getBaseStepForColor(true), getHorizontalStepKeys(ev));
            if (step === 0) return;
            this.value.setRawValue(this.value.rawValue, {
                forceEmit: true,
                last: true
            });
        }
    }
    const className$9 = ClassName('coltxt');
    function createModeSelectElement(doc) {
        const selectElem = doc.createElement('select');
        const items = [
            {
                text: 'RGB',
                value: 'rgb'
            },
            {
                text: 'HSL',
                value: 'hsl'
            },
            {
                text: 'HSV',
                value: 'hsv'
            }
        ];
        selectElem.appendChild(items.reduce((frag, item)=>{
            const optElem = doc.createElement('option');
            optElem.textContent = item.text;
            optElem.value = item.value;
            frag.appendChild(optElem);
            return frag;
        }, doc.createDocumentFragment()));
        return selectElem;
    }
    class ColorTextView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$9());
            config.viewProps.bindClassModifiers(this.element);
            const modeElem = doc.createElement('div');
            modeElem.classList.add(className$9('m'));
            this.modeElem_ = createModeSelectElement(doc);
            this.modeElem_.classList.add(className$9('ms'));
            modeElem.appendChild(this.modeSelectElement);
            config.viewProps.bindDisabled(this.modeElem_);
            const modeMarkerElem = doc.createElement('div');
            modeMarkerElem.classList.add(className$9('mm'));
            modeMarkerElem.appendChild(createSvgIconElement(doc, 'dropdown'));
            modeElem.appendChild(modeMarkerElem);
            this.element.appendChild(modeElem);
            const textsElem = doc.createElement('div');
            textsElem.classList.add(className$9('w'));
            this.element.appendChild(textsElem);
            this.textsElem_ = textsElem;
            this.textViews_ = config.textViews;
            this.applyTextViews_();
            bindValue(config.colorMode, (mode)=>{
                this.modeElem_.value = mode;
            });
        }
        get modeSelectElement() {
            return this.modeElem_;
        }
        get textViews() {
            return this.textViews_;
        }
        set textViews(textViews) {
            this.textViews_ = textViews;
            this.applyTextViews_();
        }
        applyTextViews_() {
            removeChildElements(this.textsElem_);
            const doc = this.element.ownerDocument;
            this.textViews_.forEach((v)=>{
                const compElem = doc.createElement('div');
                compElem.classList.add(className$9('c'));
                compElem.appendChild(v.element);
                this.textsElem_.appendChild(compElem);
            });
        }
    }
    function createFormatter$2(type) {
        return createNumberFormatter(type === 'float' ? 2 : 0);
    }
    function createConstraint$5(mode, type, index) {
        const max = getColorMaxComponents(mode, type)[index];
        return new DefiniteRangeConstraint({
            min: 0,
            max: max
        });
    }
    function createComponentController(doc, config, index) {
        return new NumberTextController(doc, {
            arrayPosition: index === 0 ? 'fst' : index === 2 ? 'lst' : 'mid',
            baseStep: getBaseStepForColor(false),
            parser: config.parser,
            props: ValueMap.fromObject({
                draggingScale: config.colorType === 'float' ? 0.01 : 1,
                formatter: createFormatter$2(config.colorType)
            }),
            value: createValue(0, {
                constraint: createConstraint$5(config.colorMode, config.colorType, index)
            }),
            viewProps: config.viewProps
        });
    }
    class ColorTextController {
        constructor(doc, config){
            this.onModeSelectChange_ = this.onModeSelectChange_.bind(this);
            this.colorType_ = config.colorType;
            this.parser_ = config.parser;
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.colorMode = createValue(this.value.rawValue.mode);
            this.ccs_ = this.createComponentControllers_(doc);
            this.view = new ColorTextView(doc, {
                colorMode: this.colorMode,
                textViews: [
                    this.ccs_[0].view,
                    this.ccs_[1].view,
                    this.ccs_[2].view
                ],
                viewProps: this.viewProps
            });
            this.view.modeSelectElement.addEventListener('change', this.onModeSelectChange_);
        }
        createComponentControllers_(doc) {
            const cc = {
                colorMode: this.colorMode.rawValue,
                colorType: this.colorType_,
                parser: this.parser_,
                viewProps: this.viewProps
            };
            const ccs = [
                createComponentController(doc, cc, 0),
                createComponentController(doc, cc, 1),
                createComponentController(doc, cc, 2)
            ];
            ccs.forEach((cs, index)=>{
                connectValues({
                    primary: this.value,
                    secondary: cs.value,
                    forward: (p)=>{
                        return p.rawValue.getComponents(this.colorMode.rawValue, this.colorType_)[index];
                    },
                    backward: (p, s)=>{
                        const pickedMode = this.colorMode.rawValue;
                        const comps = p.rawValue.getComponents(pickedMode, this.colorType_);
                        comps[index] = s.rawValue;
                        return new Color(appendAlphaComponent(removeAlphaComponent(comps), comps[3]), pickedMode, this.colorType_);
                    }
                });
            });
            return ccs;
        }
        onModeSelectChange_(ev) {
            const selectElem = ev.currentTarget;
            this.colorMode.rawValue = selectElem.value;
            this.ccs_ = this.createComponentControllers_(this.view.element.ownerDocument);
            this.view.textViews = [
                this.ccs_[0].view,
                this.ccs_[1].view,
                this.ccs_[2].view
            ];
        }
    }
    const className$8 = ClassName('hpl');
    class HPaletteView {
        constructor(doc, config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.value = config.value;
            this.value.emitter.on('change', this.onValueChange_);
            this.element = doc.createElement('div');
            this.element.classList.add(className$8());
            config.viewProps.bindClassModifiers(this.element);
            config.viewProps.bindTabIndex(this.element);
            const colorElem = doc.createElement('div');
            colorElem.classList.add(className$8('c'));
            this.element.appendChild(colorElem);
            const markerElem = doc.createElement('div');
            markerElem.classList.add(className$8('m'));
            this.element.appendChild(markerElem);
            this.markerElem_ = markerElem;
            this.update_();
        }
        update_() {
            const c = this.value.rawValue;
            const [h] = c.getComponents('hsv');
            this.markerElem_.style.backgroundColor = colorToFunctionalRgbString(new Color([
                h,
                100,
                100
            ], 'hsv'));
            const left = mapRange(h, 0, 360, 0, 100);
            this.markerElem_.style.left = `${left}%`;
        }
        onValueChange_() {
            this.update_();
        }
    }
    class HPaletteController {
        constructor(doc, config){
            this.onKeyDown_ = this.onKeyDown_.bind(this);
            this.onKeyUp_ = this.onKeyUp_.bind(this);
            this.onPointerDown_ = this.onPointerDown_.bind(this);
            this.onPointerMove_ = this.onPointerMove_.bind(this);
            this.onPointerUp_ = this.onPointerUp_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new HPaletteView(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            this.ptHandler_ = new PointerHandler(this.view.element);
            this.ptHandler_.emitter.on('down', this.onPointerDown_);
            this.ptHandler_.emitter.on('move', this.onPointerMove_);
            this.ptHandler_.emitter.on('up', this.onPointerUp_);
            this.view.element.addEventListener('keydown', this.onKeyDown_);
            this.view.element.addEventListener('keyup', this.onKeyUp_);
        }
        handlePointerEvent_(d, opts) {
            if (!d.point) return;
            const hue = mapRange(constrainRange(d.point.x, 0, d.bounds.width), 0, d.bounds.width, 0, 360);
            const c = this.value.rawValue;
            const [, s, v, a] = c.getComponents('hsv');
            this.value.setRawValue(new Color([
                hue,
                s,
                v,
                a
            ], 'hsv'), opts);
        }
        onPointerDown_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerMove_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerUp_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: true,
                last: true
            });
        }
        onKeyDown_(ev) {
            const step = getStepForKey(getBaseStepForColor(false), getHorizontalStepKeys(ev));
            if (step === 0) return;
            const c = this.value.rawValue;
            const [h, s, v, a] = c.getComponents('hsv');
            this.value.setRawValue(new Color([
                h + step,
                s,
                v,
                a
            ], 'hsv'), {
                forceEmit: false,
                last: false
            });
        }
        onKeyUp_(ev) {
            const step = getStepForKey(getBaseStepForColor(false), getHorizontalStepKeys(ev));
            if (step === 0) return;
            this.value.setRawValue(this.value.rawValue, {
                forceEmit: true,
                last: true
            });
        }
    }
    const className$7 = ClassName('svp');
    const CANVAS_RESOL = 64;
    class SvPaletteView {
        constructor(doc, config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.value = config.value;
            this.value.emitter.on('change', this.onValueChange_);
            this.element = doc.createElement('div');
            this.element.classList.add(className$7());
            config.viewProps.bindClassModifiers(this.element);
            config.viewProps.bindTabIndex(this.element);
            const canvasElem = doc.createElement('canvas');
            canvasElem.height = CANVAS_RESOL;
            canvasElem.width = CANVAS_RESOL;
            canvasElem.classList.add(className$7('c'));
            this.element.appendChild(canvasElem);
            this.canvasElement = canvasElem;
            const markerElem = doc.createElement('div');
            markerElem.classList.add(className$7('m'));
            this.element.appendChild(markerElem);
            this.markerElem_ = markerElem;
            this.update_();
        }
        update_() {
            const ctx = getCanvasContext(this.canvasElement);
            if (!ctx) return;
            const c = this.value.rawValue;
            const hsvComps = c.getComponents('hsv');
            const width = this.canvasElement.width;
            const height = this.canvasElement.height;
            const imgData = ctx.getImageData(0, 0, width, height);
            const data = imgData.data;
            for(let iy = 0; iy < height; iy++)for(let ix = 0; ix < width; ix++){
                const s = mapRange(ix, 0, width, 0, 100);
                const v = mapRange(iy, 0, height, 100, 0);
                const rgbComps = hsvToRgbInt(hsvComps[0], s, v);
                const i = (iy * width + ix) * 4;
                data[i] = rgbComps[0];
                data[i + 1] = rgbComps[1];
                data[i + 2] = rgbComps[2];
                data[i + 3] = 255;
            }
            ctx.putImageData(imgData, 0, 0);
            const left = mapRange(hsvComps[1], 0, 100, 0, 100);
            this.markerElem_.style.left = `${left}%`;
            const top = mapRange(hsvComps[2], 0, 100, 100, 0);
            this.markerElem_.style.top = `${top}%`;
        }
        onValueChange_() {
            this.update_();
        }
    }
    class SvPaletteController {
        constructor(doc, config){
            this.onKeyDown_ = this.onKeyDown_.bind(this);
            this.onKeyUp_ = this.onKeyUp_.bind(this);
            this.onPointerDown_ = this.onPointerDown_.bind(this);
            this.onPointerMove_ = this.onPointerMove_.bind(this);
            this.onPointerUp_ = this.onPointerUp_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new SvPaletteView(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            this.ptHandler_ = new PointerHandler(this.view.element);
            this.ptHandler_.emitter.on('down', this.onPointerDown_);
            this.ptHandler_.emitter.on('move', this.onPointerMove_);
            this.ptHandler_.emitter.on('up', this.onPointerUp_);
            this.view.element.addEventListener('keydown', this.onKeyDown_);
            this.view.element.addEventListener('keyup', this.onKeyUp_);
        }
        handlePointerEvent_(d, opts) {
            if (!d.point) return;
            const saturation = mapRange(d.point.x, 0, d.bounds.width, 0, 100);
            const value = mapRange(d.point.y, 0, d.bounds.height, 100, 0);
            const [h, , , a] = this.value.rawValue.getComponents('hsv');
            this.value.setRawValue(new Color([
                h,
                saturation,
                value,
                a
            ], 'hsv'), opts);
        }
        onPointerDown_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerMove_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerUp_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: true,
                last: true
            });
        }
        onKeyDown_(ev) {
            if (isArrowKey(ev.key)) ev.preventDefault();
            const [h, s, v, a] = this.value.rawValue.getComponents('hsv');
            const baseStep = getBaseStepForColor(false);
            const ds = getStepForKey(baseStep, getHorizontalStepKeys(ev));
            const dv = getStepForKey(baseStep, getVerticalStepKeys(ev));
            if (ds === 0 && dv === 0) return;
            this.value.setRawValue(new Color([
                h,
                s + ds,
                v + dv,
                a
            ], 'hsv'), {
                forceEmit: false,
                last: false
            });
        }
        onKeyUp_(ev) {
            const baseStep = getBaseStepForColor(false);
            const ds = getStepForKey(baseStep, getHorizontalStepKeys(ev));
            const dv = getStepForKey(baseStep, getVerticalStepKeys(ev));
            if (ds === 0 && dv === 0) return;
            this.value.setRawValue(this.value.rawValue, {
                forceEmit: true,
                last: true
            });
        }
    }
    class ColorPickerController {
        constructor(doc, config){
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.hPaletteC_ = new HPaletteController(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            this.svPaletteC_ = new SvPaletteController(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            this.alphaIcs_ = config.supportsAlpha ? {
                palette: new APaletteController(doc, {
                    value: this.value,
                    viewProps: this.viewProps
                }),
                text: new NumberTextController(doc, {
                    parser: parseNumber,
                    baseStep: 0.1,
                    props: ValueMap.fromObject({
                        draggingScale: 0.01,
                        formatter: createNumberFormatter(2)
                    }),
                    value: createValue(0, {
                        constraint: new DefiniteRangeConstraint({
                            min: 0,
                            max: 1
                        })
                    }),
                    viewProps: this.viewProps
                })
            } : null;
            if (this.alphaIcs_) connectValues({
                primary: this.value,
                secondary: this.alphaIcs_.text.value,
                forward: (p)=>{
                    return p.rawValue.getComponents()[3];
                },
                backward: (p, s)=>{
                    const comps = p.rawValue.getComponents();
                    comps[3] = s.rawValue;
                    return new Color(comps, p.rawValue.mode);
                }
            });
            this.textC_ = new ColorTextController(doc, {
                colorType: config.colorType,
                parser: parseNumber,
                value: this.value,
                viewProps: this.viewProps
            });
            this.view = new ColorPickerView(doc, {
                alphaViews: this.alphaIcs_ ? {
                    palette: this.alphaIcs_.palette.view,
                    text: this.alphaIcs_.text.view
                } : null,
                hPaletteView: this.hPaletteC_.view,
                supportsAlpha: config.supportsAlpha,
                svPaletteView: this.svPaletteC_.view,
                textView: this.textC_.view,
                viewProps: this.viewProps
            });
        }
        get textController() {
            return this.textC_;
        }
    }
    const className$6 = ClassName('colsw');
    class ColorSwatchView {
        constructor(doc, config){
            this.onValueChange_ = this.onValueChange_.bind(this);
            config.value.emitter.on('change', this.onValueChange_);
            this.value = config.value;
            this.element = doc.createElement('div');
            this.element.classList.add(className$6());
            config.viewProps.bindClassModifiers(this.element);
            const swatchElem = doc.createElement('div');
            swatchElem.classList.add(className$6('sw'));
            this.element.appendChild(swatchElem);
            this.swatchElem_ = swatchElem;
            const buttonElem = doc.createElement('button');
            buttonElem.classList.add(className$6('b'));
            config.viewProps.bindDisabled(buttonElem);
            this.element.appendChild(buttonElem);
            this.buttonElement = buttonElem;
            this.update_();
        }
        update_() {
            const value = this.value.rawValue;
            this.swatchElem_.style.backgroundColor = colorToHexRgbaString(value);
        }
        onValueChange_() {
            this.update_();
        }
    }
    class ColorSwatchController {
        constructor(doc, config){
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new ColorSwatchView(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
        }
    }
    class ColorController {
        constructor(doc, config){
            this.onButtonBlur_ = this.onButtonBlur_.bind(this);
            this.onButtonClick_ = this.onButtonClick_.bind(this);
            this.onPopupChildBlur_ = this.onPopupChildBlur_.bind(this);
            this.onPopupChildKeydown_ = this.onPopupChildKeydown_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.foldable_ = Foldable.create(config.expanded);
            this.swatchC_ = new ColorSwatchController(doc, {
                value: this.value,
                viewProps: this.viewProps
            });
            const buttonElem = this.swatchC_.view.buttonElement;
            buttonElem.addEventListener('blur', this.onButtonBlur_);
            buttonElem.addEventListener('click', this.onButtonClick_);
            this.textC_ = new TextController(doc, {
                parser: config.parser,
                props: ValueMap.fromObject({
                    formatter: config.formatter
                }),
                value: this.value,
                viewProps: this.viewProps
            });
            this.view = new ColorView(doc, {
                foldable: this.foldable_,
                pickerLayout: config.pickerLayout
            });
            this.view.swatchElement.appendChild(this.swatchC_.view.element);
            this.view.textElement.appendChild(this.textC_.view.element);
            this.popC_ = config.pickerLayout === 'popup' ? new PopupController(doc, {
                viewProps: this.viewProps
            }) : null;
            const pickerC = new ColorPickerController(doc, {
                colorType: config.colorType,
                supportsAlpha: config.supportsAlpha,
                value: this.value,
                viewProps: this.viewProps
            });
            pickerC.view.allFocusableElements.forEach((elem)=>{
                elem.addEventListener('blur', this.onPopupChildBlur_);
                elem.addEventListener('keydown', this.onPopupChildKeydown_);
            });
            this.pickerC_ = pickerC;
            if (this.popC_) {
                this.view.element.appendChild(this.popC_.view.element);
                this.popC_.view.element.appendChild(pickerC.view.element);
                connectValues({
                    primary: this.foldable_.value('expanded'),
                    secondary: this.popC_.shows,
                    forward: (p)=>p.rawValue,
                    backward: (_, s)=>s.rawValue
                });
            } else if (this.view.pickerElement) {
                this.view.pickerElement.appendChild(this.pickerC_.view.element);
                bindFoldable(this.foldable_, this.view.pickerElement);
            }
        }
        get textController() {
            return this.textC_;
        }
        onButtonBlur_(e) {
            if (!this.popC_) return;
            const elem = this.view.element;
            const nextTarget = forceCast(e.relatedTarget);
            if (!nextTarget || !elem.contains(nextTarget)) this.popC_.shows.rawValue = false;
        }
        onButtonClick_() {
            this.foldable_.set('expanded', !this.foldable_.get('expanded'));
            if (this.foldable_.get('expanded')) this.pickerC_.view.allFocusableElements[0].focus();
        }
        onPopupChildBlur_(ev) {
            if (!this.popC_) return;
            const elem = this.popC_.view.element;
            const nextTarget = findNextTarget(ev);
            if (nextTarget && elem.contains(nextTarget)) return;
            if (nextTarget && nextTarget === this.swatchC_.view.buttonElement && !supportsTouch(elem.ownerDocument)) return;
            this.popC_.shows.rawValue = false;
        }
        onPopupChildKeydown_(ev) {
            if (this.popC_) {
                if (ev.key === 'Escape') this.popC_.shows.rawValue = false;
            } else if (this.view.pickerElement) {
                if (ev.key === 'Escape') this.swatchC_.view.buttonElement.focus();
            }
        }
    }
    function colorFromObject(value, opt_type) {
        if (Color.isColorObject(value)) return Color.fromObject(value, opt_type);
        return Color.black(opt_type);
    }
    function colorToRgbNumber(value) {
        return removeAlphaComponent(value.getComponents('rgb')).reduce((result, comp)=>{
            return result << 8 | Math.floor(comp) & 0xff;
        }, 0);
    }
    function colorToRgbaNumber(value) {
        return value.getComponents('rgb').reduce((result, comp, index)=>{
            const hex = Math.floor(index === 3 ? comp * 255 : comp) & 0xff;
            return result << 8 | hex;
        }, 0) >>> 0;
    }
    function numberToRgbColor(num) {
        return new Color([
            num >> 16 & 0xff,
            num >> 8 & 0xff,
            num & 0xff
        ], 'rgb');
    }
    function numberToRgbaColor(num) {
        return new Color([
            num >> 24 & 0xff,
            num >> 16 & 0xff,
            num >> 8 & 0xff,
            mapRange(num & 0xff, 0, 255, 0, 1)
        ], 'rgb');
    }
    function colorFromRgbNumber(value) {
        if (typeof value !== 'number') return Color.black();
        return numberToRgbColor(value);
    }
    function colorFromRgbaNumber(value) {
        if (typeof value !== 'number') return Color.black();
        return numberToRgbaColor(value);
    }
    function createColorStringWriter(format) {
        const stringify = findColorStringifier(format);
        return stringify ? (target, value)=>{
            writePrimitive(target, stringify(value));
        } : null;
    }
    function createColorNumberWriter(supportsAlpha) {
        const colorToNumber = supportsAlpha ? colorToRgbaNumber : colorToRgbNumber;
        return (target, value)=>{
            writePrimitive(target, colorToNumber(value));
        };
    }
    function writeRgbaColorObject(target, value, opt_type) {
        const obj = value.toRgbaObject(opt_type);
        target.writeProperty('r', obj.r);
        target.writeProperty('g', obj.g);
        target.writeProperty('b', obj.b);
        target.writeProperty('a', obj.a);
    }
    function writeRgbColorObject(target, value, opt_type) {
        const obj = value.toRgbaObject(opt_type);
        target.writeProperty('r', obj.r);
        target.writeProperty('g', obj.g);
        target.writeProperty('b', obj.b);
    }
    function createColorObjectWriter(supportsAlpha, opt_type) {
        return (target, inValue)=>{
            if (supportsAlpha) writeRgbaColorObject(target, inValue, opt_type);
            else writeRgbColorObject(target, inValue, opt_type);
        };
    }
    function shouldSupportAlpha$1(inputParams) {
        var _a;
        if ((inputParams === null || inputParams === void 0 ? void 0 : inputParams.alpha) || ((_a = inputParams === null || inputParams === void 0 ? void 0 : inputParams.color) === null || _a === void 0 ? void 0 : _a.alpha)) return true;
        return false;
    }
    function createFormatter$1(supportsAlpha) {
        return supportsAlpha ? (v)=>colorToHexRgbaString(v, '0x') : (v)=>colorToHexRgbString(v, '0x');
    }
    function isForColor(params) {
        if ('color' in params) return true;
        if ('view' in params && params.view === 'color') return true;
        return false;
    }
    const NumberColorInputPlugin = {
        id: 'input-color-number',
        type: 'input',
        accept: (value, params)=>{
            if (typeof value !== 'number') return null;
            if (!isForColor(params)) return null;
            const result = parseColorInputParams(params);
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (args)=>{
                return shouldSupportAlpha$1(args.params) ? colorFromRgbaNumber : colorFromRgbNumber;
            },
            equals: Color.equals,
            writer: (args)=>{
                return createColorNumberWriter(shouldSupportAlpha$1(args.params));
            }
        },
        controller: (args)=>{
            const supportsAlpha = shouldSupportAlpha$1(args.params);
            const expanded = 'expanded' in args.params ? args.params.expanded : undefined;
            const picker = 'picker' in args.params ? args.params.picker : undefined;
            return new ColorController(args.document, {
                colorType: 'int',
                expanded: expanded !== null && expanded !== void 0 ? expanded : false,
                formatter: createFormatter$1(supportsAlpha),
                parser: createColorStringParser('int'),
                pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup',
                supportsAlpha: supportsAlpha,
                value: args.value,
                viewProps: args.viewProps
            });
        }
    };
    function shouldSupportAlpha(initialValue) {
        return Color.isRgbaColorObject(initialValue);
    }
    function createColorObjectReader(opt_type) {
        return (value)=>{
            return colorFromObject(value, opt_type);
        };
    }
    function createColorObjectFormatter(supportsAlpha, type) {
        return (value)=>{
            if (supportsAlpha) return colorToObjectRgbaString(value, type);
            return colorToObjectRgbString(value, type);
        };
    }
    const ObjectColorInputPlugin = {
        id: 'input-color-object',
        type: 'input',
        accept: (value, params)=>{
            if (!Color.isColorObject(value)) return null;
            const result = parseColorInputParams(params);
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (args)=>createColorObjectReader(extractColorType(args.params)),
            equals: Color.equals,
            writer: (args)=>createColorObjectWriter(shouldSupportAlpha(args.initialValue), extractColorType(args.params))
        },
        controller: (args)=>{
            var _a;
            const supportsAlpha = Color.isRgbaColorObject(args.initialValue);
            const expanded = 'expanded' in args.params ? args.params.expanded : undefined;
            const picker = 'picker' in args.params ? args.params.picker : undefined;
            const type = (_a = extractColorType(args.params)) !== null && _a !== void 0 ? _a : 'int';
            return new ColorController(args.document, {
                colorType: type,
                expanded: expanded !== null && expanded !== void 0 ? expanded : false,
                formatter: createColorObjectFormatter(supportsAlpha, type),
                parser: createColorStringParser(type),
                pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup',
                supportsAlpha: supportsAlpha,
                value: args.value,
                viewProps: args.viewProps
            });
        }
    };
    const StringColorInputPlugin = {
        id: 'input-color-string',
        type: 'input',
        accept: (value, params)=>{
            if (typeof value !== 'string') return null;
            if ('view' in params && params.view === 'text') return null;
            const format = detectStringColorFormat(value, extractColorType(params));
            if (!format) return null;
            const stringifier = findColorStringifier(format);
            if (!stringifier) return null;
            const result = parseColorInputParams(params);
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (args)=>{
                var _a;
                return createColorStringBindingReader((_a = extractColorType(args.params)) !== null && _a !== void 0 ? _a : 'int');
            },
            equals: Color.equals,
            writer: (args)=>{
                const format = detectStringColorFormat(args.initialValue, extractColorType(args.params));
                if (!format) throw TpError.shouldNeverHappen();
                const writer = createColorStringWriter(format);
                if (!writer) throw TpError.notBindable();
                return writer;
            }
        },
        controller: (args)=>{
            const format = detectStringColorFormat(args.initialValue, extractColorType(args.params));
            if (!format) throw TpError.shouldNeverHappen();
            const stringifier = findColorStringifier(format);
            if (!stringifier) throw TpError.shouldNeverHappen();
            const expanded = 'expanded' in args.params ? args.params.expanded : undefined;
            const picker = 'picker' in args.params ? args.params.picker : undefined;
            return new ColorController(args.document, {
                colorType: format.type,
                expanded: expanded !== null && expanded !== void 0 ? expanded : false,
                formatter: stringifier,
                parser: createColorStringParser(format.type),
                pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup',
                supportsAlpha: format.alpha,
                value: args.value,
                viewProps: args.viewProps
            });
        }
    };
    class PointNdConstraint {
        constructor(config){
            this.components = config.components;
            this.asm_ = config.assembly;
        }
        constrain(value) {
            const comps = this.asm_.toComponents(value).map((comp, index)=>{
                var _a, _b;
                return (_b = (_a = this.components[index]) === null || _a === void 0 ? void 0 : _a.constrain(comp)) !== null && _b !== void 0 ? _b : comp;
            });
            return this.asm_.fromComponents(comps);
        }
    }
    const className$5 = ClassName('pndtxt');
    class PointNdTextView {
        constructor(doc, config){
            this.textViews = config.textViews;
            this.element = doc.createElement('div');
            this.element.classList.add(className$5());
            this.textViews.forEach((v)=>{
                const axisElem = doc.createElement('div');
                axisElem.classList.add(className$5('a'));
                axisElem.appendChild(v.element);
                this.element.appendChild(axisElem);
            });
        }
    }
    function createAxisController(doc, config, index) {
        return new NumberTextController(doc, {
            arrayPosition: index === 0 ? 'fst' : index === config.axes.length - 1 ? 'lst' : 'mid',
            baseStep: config.axes[index].baseStep,
            parser: config.parser,
            props: config.axes[index].textProps,
            value: createValue(0, {
                constraint: config.axes[index].constraint
            }),
            viewProps: config.viewProps
        });
    }
    class PointNdTextController {
        constructor(doc, config){
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.acs_ = config.axes.map((_, index)=>createAxisController(doc, config, index));
            this.acs_.forEach((c, index)=>{
                connectValues({
                    primary: this.value,
                    secondary: c.value,
                    forward: (p)=>{
                        return config.assembly.toComponents(p.rawValue)[index];
                    },
                    backward: (p, s)=>{
                        const comps = config.assembly.toComponents(p.rawValue);
                        comps[index] = s.rawValue;
                        return config.assembly.fromComponents(comps);
                    }
                });
            });
            this.view = new PointNdTextView(doc, {
                textViews: this.acs_.map((ac)=>ac.view)
            });
        }
    }
    function createStepConstraint(params, initialValue) {
        if ('step' in params && !isEmpty(params.step)) return new StepConstraint(params.step, initialValue);
        return null;
    }
    function createRangeConstraint(params) {
        if (!isEmpty(params.max) && !isEmpty(params.min)) return new DefiniteRangeConstraint({
            max: params.max,
            min: params.min
        });
        if (!isEmpty(params.max) || !isEmpty(params.min)) return new RangeConstraint({
            max: params.max,
            min: params.min
        });
        return null;
    }
    function findNumberRange(c) {
        const drc = findConstraint(c, DefiniteRangeConstraint);
        if (drc) return [
            drc.values.get('min'),
            drc.values.get('max')
        ];
        const rc = findConstraint(c, RangeConstraint);
        if (rc) return [
            rc.minValue,
            rc.maxValue
        ];
        return [
            undefined,
            undefined
        ];
    }
    function createConstraint$4(params, initialValue) {
        const constraints = [];
        const sc = createStepConstraint(params, initialValue);
        if (sc) constraints.push(sc);
        const rc = createRangeConstraint(params);
        if (rc) constraints.push(rc);
        const lc = createListConstraint(params.options);
        if (lc) constraints.push(lc);
        return new CompositeConstraint(constraints);
    }
    const NumberInputPlugin = {
        id: 'input-number',
        type: 'input',
        accept: (value, params)=>{
            if (typeof value !== 'number') return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                format: p.optional.function,
                max: p.optional.number,
                min: p.optional.number,
                options: p.optional.custom(parseListOptions),
                step: p.optional.number
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>numberFromUnknown,
            constraint: (args)=>createConstraint$4(args.params, args.initialValue),
            writer: (_args)=>writePrimitive
        },
        controller: (args)=>{
            var _a;
            const value = args.value;
            const c = args.constraint;
            const lc = c && findConstraint(c, ListConstraint);
            if (lc) return new ListController(args.document, {
                props: new ValueMap({
                    options: lc.values.value('options')
                }),
                value: value,
                viewProps: args.viewProps
            });
            const formatter = (_a = 'format' in args.params ? args.params.format : undefined) !== null && _a !== void 0 ? _a : createNumberFormatter(getSuitableDecimalDigits(c, value.rawValue));
            const drc = c && findConstraint(c, DefiniteRangeConstraint);
            if (drc) return new SliderTextController(args.document, {
                baseStep: getBaseStep(c),
                parser: parseNumber,
                sliderProps: new ValueMap({
                    maxValue: drc.values.value('max'),
                    minValue: drc.values.value('min')
                }),
                textProps: ValueMap.fromObject({
                    draggingScale: getSuitableDraggingScale(c, value.rawValue),
                    formatter: formatter
                }),
                value: value,
                viewProps: args.viewProps
            });
            return new NumberTextController(args.document, {
                baseStep: getBaseStep(c),
                parser: parseNumber,
                props: ValueMap.fromObject({
                    draggingScale: getSuitableDraggingScale(c, value.rawValue),
                    formatter: formatter
                }),
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    class Point2d {
        constructor(x = 0, y = 0){
            this.x = x;
            this.y = y;
        }
        getComponents() {
            return [
                this.x,
                this.y
            ];
        }
        static isObject(obj) {
            if (isEmpty(obj)) return false;
            const x = obj.x;
            const y = obj.y;
            if (typeof x !== 'number' || typeof y !== 'number') return false;
            return true;
        }
        static equals(v1, v2) {
            return v1.x === v2.x && v1.y === v2.y;
        }
        toObject() {
            return {
                x: this.x,
                y: this.y
            };
        }
    }
    const Point2dAssembly = {
        toComponents: (p)=>p.getComponents(),
        fromComponents: (comps)=>new Point2d(...comps)
    };
    const className$4 = ClassName('p2d');
    class Point2dView {
        constructor(doc, config){
            this.element = doc.createElement('div');
            this.element.classList.add(className$4());
            config.viewProps.bindClassModifiers(this.element);
            bindValue(config.expanded, valueToClassName(this.element, className$4(undefined, 'expanded')));
            const headElem = doc.createElement('div');
            headElem.classList.add(className$4('h'));
            this.element.appendChild(headElem);
            const buttonElem = doc.createElement('button');
            buttonElem.classList.add(className$4('b'));
            buttonElem.appendChild(createSvgIconElement(doc, 'p2dpad'));
            config.viewProps.bindDisabled(buttonElem);
            headElem.appendChild(buttonElem);
            this.buttonElement = buttonElem;
            const textElem = doc.createElement('div');
            textElem.classList.add(className$4('t'));
            headElem.appendChild(textElem);
            this.textElement = textElem;
            if (config.pickerLayout === 'inline') {
                const pickerElem = doc.createElement('div');
                pickerElem.classList.add(className$4('p'));
                this.element.appendChild(pickerElem);
                this.pickerElement = pickerElem;
            } else this.pickerElement = null;
        }
    }
    const className$3 = ClassName('p2dp');
    class Point2dPickerView {
        constructor(doc, config){
            this.onFoldableChange_ = this.onFoldableChange_.bind(this);
            this.onValueChange_ = this.onValueChange_.bind(this);
            this.invertsY_ = config.invertsY;
            this.maxValue_ = config.maxValue;
            this.element = doc.createElement('div');
            this.element.classList.add(className$3());
            if (config.layout === 'popup') this.element.classList.add(className$3(undefined, 'p'));
            config.viewProps.bindClassModifiers(this.element);
            const padElem = doc.createElement('div');
            padElem.classList.add(className$3('p'));
            config.viewProps.bindTabIndex(padElem);
            this.element.appendChild(padElem);
            this.padElement = padElem;
            const svgElem = doc.createElementNS(SVG_NS, 'svg');
            svgElem.classList.add(className$3('g'));
            this.padElement.appendChild(svgElem);
            this.svgElem_ = svgElem;
            const xAxisElem = doc.createElementNS(SVG_NS, 'line');
            xAxisElem.classList.add(className$3('ax'));
            xAxisElem.setAttributeNS(null, 'x1', '0');
            xAxisElem.setAttributeNS(null, 'y1', '50%');
            xAxisElem.setAttributeNS(null, 'x2', '100%');
            xAxisElem.setAttributeNS(null, 'y2', '50%');
            this.svgElem_.appendChild(xAxisElem);
            const yAxisElem = doc.createElementNS(SVG_NS, 'line');
            yAxisElem.classList.add(className$3('ax'));
            yAxisElem.setAttributeNS(null, 'x1', '50%');
            yAxisElem.setAttributeNS(null, 'y1', '0');
            yAxisElem.setAttributeNS(null, 'x2', '50%');
            yAxisElem.setAttributeNS(null, 'y2', '100%');
            this.svgElem_.appendChild(yAxisElem);
            const lineElem = doc.createElementNS(SVG_NS, 'line');
            lineElem.classList.add(className$3('l'));
            lineElem.setAttributeNS(null, 'x1', '50%');
            lineElem.setAttributeNS(null, 'y1', '50%');
            this.svgElem_.appendChild(lineElem);
            this.lineElem_ = lineElem;
            const markerElem = doc.createElement('div');
            markerElem.classList.add(className$3('m'));
            this.padElement.appendChild(markerElem);
            this.markerElem_ = markerElem;
            config.value.emitter.on('change', this.onValueChange_);
            this.value = config.value;
            this.update_();
        }
        get allFocusableElements() {
            return [
                this.padElement
            ];
        }
        update_() {
            const [x, y] = this.value.rawValue.getComponents();
            const max = this.maxValue_;
            const px = mapRange(x, -max, +max, 0, 100);
            const py = mapRange(y, -max, +max, 0, 100);
            const ipy = this.invertsY_ ? 100 - py : py;
            this.lineElem_.setAttributeNS(null, 'x2', `${px}%`);
            this.lineElem_.setAttributeNS(null, 'y2', `${ipy}%`);
            this.markerElem_.style.left = `${px}%`;
            this.markerElem_.style.top = `${ipy}%`;
        }
        onValueChange_() {
            this.update_();
        }
        onFoldableChange_() {
            this.update_();
        }
    }
    function computeOffset(ev, baseSteps, invertsY) {
        return [
            getStepForKey(baseSteps[0], getHorizontalStepKeys(ev)),
            getStepForKey(baseSteps[1], getVerticalStepKeys(ev)) * (invertsY ? 1 : -1)
        ];
    }
    class Point2dPickerController {
        constructor(doc, config){
            this.onPadKeyDown_ = this.onPadKeyDown_.bind(this);
            this.onPadKeyUp_ = this.onPadKeyUp_.bind(this);
            this.onPointerDown_ = this.onPointerDown_.bind(this);
            this.onPointerMove_ = this.onPointerMove_.bind(this);
            this.onPointerUp_ = this.onPointerUp_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.baseSteps_ = config.baseSteps;
            this.maxValue_ = config.maxValue;
            this.invertsY_ = config.invertsY;
            this.view = new Point2dPickerView(doc, {
                invertsY: this.invertsY_,
                layout: config.layout,
                maxValue: this.maxValue_,
                value: this.value,
                viewProps: this.viewProps
            });
            this.ptHandler_ = new PointerHandler(this.view.padElement);
            this.ptHandler_.emitter.on('down', this.onPointerDown_);
            this.ptHandler_.emitter.on('move', this.onPointerMove_);
            this.ptHandler_.emitter.on('up', this.onPointerUp_);
            this.view.padElement.addEventListener('keydown', this.onPadKeyDown_);
            this.view.padElement.addEventListener('keyup', this.onPadKeyUp_);
        }
        handlePointerEvent_(d, opts) {
            if (!d.point) return;
            const max = this.maxValue_;
            const px = mapRange(d.point.x, 0, d.bounds.width, -max, +max);
            const py = mapRange(this.invertsY_ ? d.bounds.height - d.point.y : d.point.y, 0, d.bounds.height, -max, +max);
            this.value.setRawValue(new Point2d(px, py), opts);
        }
        onPointerDown_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerMove_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: false,
                last: false
            });
        }
        onPointerUp_(ev) {
            this.handlePointerEvent_(ev.data, {
                forceEmit: true,
                last: true
            });
        }
        onPadKeyDown_(ev) {
            if (isArrowKey(ev.key)) ev.preventDefault();
            const [dx, dy] = computeOffset(ev, this.baseSteps_, this.invertsY_);
            if (dx === 0 && dy === 0) return;
            this.value.setRawValue(new Point2d(this.value.rawValue.x + dx, this.value.rawValue.y + dy), {
                forceEmit: false,
                last: false
            });
        }
        onPadKeyUp_(ev) {
            const [dx, dy] = computeOffset(ev, this.baseSteps_, this.invertsY_);
            if (dx === 0 && dy === 0) return;
            this.value.setRawValue(this.value.rawValue, {
                forceEmit: true,
                last: true
            });
        }
    }
    class Point2dController {
        constructor(doc, config){
            var _a, _b;
            this.onPopupChildBlur_ = this.onPopupChildBlur_.bind(this);
            this.onPopupChildKeydown_ = this.onPopupChildKeydown_.bind(this);
            this.onPadButtonBlur_ = this.onPadButtonBlur_.bind(this);
            this.onPadButtonClick_ = this.onPadButtonClick_.bind(this);
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.foldable_ = Foldable.create(config.expanded);
            this.popC_ = config.pickerLayout === 'popup' ? new PopupController(doc, {
                viewProps: this.viewProps
            }) : null;
            const padC = new Point2dPickerController(doc, {
                baseSteps: [
                    config.axes[0].baseStep,
                    config.axes[1].baseStep
                ],
                invertsY: config.invertsY,
                layout: config.pickerLayout,
                maxValue: config.maxValue,
                value: this.value,
                viewProps: this.viewProps
            });
            padC.view.allFocusableElements.forEach((elem)=>{
                elem.addEventListener('blur', this.onPopupChildBlur_);
                elem.addEventListener('keydown', this.onPopupChildKeydown_);
            });
            this.pickerC_ = padC;
            this.textC_ = new PointNdTextController(doc, {
                assembly: Point2dAssembly,
                axes: config.axes,
                parser: config.parser,
                value: this.value,
                viewProps: this.viewProps
            });
            this.view = new Point2dView(doc, {
                expanded: this.foldable_.value('expanded'),
                pickerLayout: config.pickerLayout,
                viewProps: this.viewProps
            });
            this.view.textElement.appendChild(this.textC_.view.element);
            (_a = this.view.buttonElement) === null || _a === void 0 || _a.addEventListener('blur', this.onPadButtonBlur_);
            (_b = this.view.buttonElement) === null || _b === void 0 || _b.addEventListener('click', this.onPadButtonClick_);
            if (this.popC_) {
                this.view.element.appendChild(this.popC_.view.element);
                this.popC_.view.element.appendChild(this.pickerC_.view.element);
                connectValues({
                    primary: this.foldable_.value('expanded'),
                    secondary: this.popC_.shows,
                    forward: (p)=>p.rawValue,
                    backward: (_, s)=>s.rawValue
                });
            } else if (this.view.pickerElement) {
                this.view.pickerElement.appendChild(this.pickerC_.view.element);
                bindFoldable(this.foldable_, this.view.pickerElement);
            }
        }
        onPadButtonBlur_(e) {
            if (!this.popC_) return;
            const elem = this.view.element;
            const nextTarget = forceCast(e.relatedTarget);
            if (!nextTarget || !elem.contains(nextTarget)) this.popC_.shows.rawValue = false;
        }
        onPadButtonClick_() {
            this.foldable_.set('expanded', !this.foldable_.get('expanded'));
            if (this.foldable_.get('expanded')) this.pickerC_.view.allFocusableElements[0].focus();
        }
        onPopupChildBlur_(ev) {
            if (!this.popC_) return;
            const elem = this.popC_.view.element;
            const nextTarget = findNextTarget(ev);
            if (nextTarget && elem.contains(nextTarget)) return;
            if (nextTarget && nextTarget === this.view.buttonElement && !supportsTouch(elem.ownerDocument)) return;
            this.popC_.shows.rawValue = false;
        }
        onPopupChildKeydown_(ev) {
            if (this.popC_) {
                if (ev.key === 'Escape') this.popC_.shows.rawValue = false;
            } else if (this.view.pickerElement) {
                if (ev.key === 'Escape') this.view.buttonElement.focus();
            }
        }
    }
    class Point3d {
        constructor(x = 0, y = 0, z = 0){
            this.x = x;
            this.y = y;
            this.z = z;
        }
        getComponents() {
            return [
                this.x,
                this.y,
                this.z
            ];
        }
        static isObject(obj) {
            if (isEmpty(obj)) return false;
            const x = obj.x;
            const y = obj.y;
            const z = obj.z;
            if (typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number') return false;
            return true;
        }
        static equals(v1, v2) {
            return v1.x === v2.x && v1.y === v2.y && v1.z === v2.z;
        }
        toObject() {
            return {
                x: this.x,
                y: this.y,
                z: this.z
            };
        }
    }
    const Point3dAssembly = {
        toComponents: (p)=>p.getComponents(),
        fromComponents: (comps)=>new Point3d(...comps)
    };
    function point3dFromUnknown(value) {
        return Point3d.isObject(value) ? new Point3d(value.x, value.y, value.z) : new Point3d();
    }
    function writePoint3d(target, value) {
        target.writeProperty('x', value.x);
        target.writeProperty('y', value.y);
        target.writeProperty('z', value.z);
    }
    function createConstraint$3(params, initialValue) {
        return new PointNdConstraint({
            assembly: Point3dAssembly,
            components: [
                createDimensionConstraint('x' in params ? params.x : undefined, initialValue.x),
                createDimensionConstraint('y' in params ? params.y : undefined, initialValue.y),
                createDimensionConstraint('z' in params ? params.z : undefined, initialValue.z)
            ]
        });
    }
    function createAxis$2(initialValue, constraint) {
        return {
            baseStep: getBaseStep(constraint),
            constraint: constraint,
            textProps: ValueMap.fromObject({
                draggingScale: getSuitableDraggingScale(constraint, initialValue),
                formatter: createNumberFormatter(getSuitableDecimalDigits(constraint, initialValue))
            })
        };
    }
    const Point3dInputPlugin = {
        id: 'input-point3d',
        type: 'input',
        accept: (value, params)=>{
            if (!Point3d.isObject(value)) return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                x: p.optional.custom(parsePointDimensionParams),
                y: p.optional.custom(parsePointDimensionParams),
                z: p.optional.custom(parsePointDimensionParams)
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>point3dFromUnknown,
            constraint: (args)=>createConstraint$3(args.params, args.initialValue),
            equals: Point3d.equals,
            writer: (_args)=>writePoint3d
        },
        controller: (args)=>{
            const value = args.value;
            const c = args.constraint;
            if (!(c instanceof PointNdConstraint)) throw TpError.shouldNeverHappen();
            return new PointNdTextController(args.document, {
                assembly: Point3dAssembly,
                axes: [
                    createAxis$2(value.rawValue.x, c.components[0]),
                    createAxis$2(value.rawValue.y, c.components[1]),
                    createAxis$2(value.rawValue.z, c.components[2])
                ],
                parser: parseNumber,
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    class Point4d {
        constructor(x = 0, y = 0, z = 0, w = 0){
            this.x = x;
            this.y = y;
            this.z = z;
            this.w = w;
        }
        getComponents() {
            return [
                this.x,
                this.y,
                this.z,
                this.w
            ];
        }
        static isObject(obj) {
            if (isEmpty(obj)) return false;
            const x = obj.x;
            const y = obj.y;
            const z = obj.z;
            const w = obj.w;
            if (typeof x !== 'number' || typeof y !== 'number' || typeof z !== 'number' || typeof w !== 'number') return false;
            return true;
        }
        static equals(v1, v2) {
            return v1.x === v2.x && v1.y === v2.y && v1.z === v2.z && v1.w === v2.w;
        }
        toObject() {
            return {
                x: this.x,
                y: this.y,
                z: this.z,
                w: this.w
            };
        }
    }
    const Point4dAssembly = {
        toComponents: (p)=>p.getComponents(),
        fromComponents: (comps)=>new Point4d(...comps)
    };
    function point4dFromUnknown(value) {
        return Point4d.isObject(value) ? new Point4d(value.x, value.y, value.z, value.w) : new Point4d();
    }
    function writePoint4d(target, value) {
        target.writeProperty('x', value.x);
        target.writeProperty('y', value.y);
        target.writeProperty('z', value.z);
        target.writeProperty('w', value.w);
    }
    function createConstraint$2(params, initialValue) {
        return new PointNdConstraint({
            assembly: Point4dAssembly,
            components: [
                createDimensionConstraint('x' in params ? params.x : undefined, initialValue.x),
                createDimensionConstraint('y' in params ? params.y : undefined, initialValue.y),
                createDimensionConstraint('z' in params ? params.z : undefined, initialValue.z),
                createDimensionConstraint('w' in params ? params.w : undefined, initialValue.w)
            ]
        });
    }
    function createAxis$1(initialValue, constraint) {
        return {
            baseStep: getBaseStep(constraint),
            constraint: constraint,
            textProps: ValueMap.fromObject({
                draggingScale: getSuitableDraggingScale(constraint, initialValue),
                formatter: createNumberFormatter(getSuitableDecimalDigits(constraint, initialValue))
            })
        };
    }
    const Point4dInputPlugin = {
        id: 'input-point4d',
        type: 'input',
        accept: (value, params)=>{
            if (!Point4d.isObject(value)) return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                x: p.optional.custom(parsePointDimensionParams),
                y: p.optional.custom(parsePointDimensionParams),
                z: p.optional.custom(parsePointDimensionParams),
                w: p.optional.custom(parsePointDimensionParams)
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>point4dFromUnknown,
            constraint: (args)=>createConstraint$2(args.params, args.initialValue),
            equals: Point4d.equals,
            writer: (_args)=>writePoint4d
        },
        controller: (args)=>{
            const value = args.value;
            const c = args.constraint;
            if (!(c instanceof PointNdConstraint)) throw TpError.shouldNeverHappen();
            return new PointNdTextController(args.document, {
                assembly: Point4dAssembly,
                axes: value.rawValue.getComponents().map((comp, index)=>createAxis$1(comp, c.components[index])),
                parser: parseNumber,
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    function createConstraint$1(params) {
        const constraints = [];
        const lc = createListConstraint(params.options);
        if (lc) constraints.push(lc);
        return new CompositeConstraint(constraints);
    }
    const StringInputPlugin = {
        id: 'input-string',
        type: 'input',
        accept: (value, params)=>{
            if (typeof value !== 'string') return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                options: p.optional.custom(parseListOptions)
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>stringFromUnknown,
            constraint: (args)=>createConstraint$1(args.params),
            writer: (_args)=>writePrimitive
        },
        controller: (args)=>{
            const doc = args.document;
            const value = args.value;
            const c = args.constraint;
            const lc = c && findConstraint(c, ListConstraint);
            if (lc) return new ListController(doc, {
                props: new ValueMap({
                    options: lc.values.value('options')
                }),
                value: value,
                viewProps: args.viewProps
            });
            return new TextController(doc, {
                parser: (v)=>v,
                props: ValueMap.fromObject({
                    formatter: formatString
                }),
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    const Constants = {
        monitor: {
            defaultInterval: 200,
            defaultLineCount: 3
        }
    };
    const className$2 = ClassName('mll');
    class MultiLogView {
        constructor(doc, config){
            this.onValueUpdate_ = this.onValueUpdate_.bind(this);
            this.formatter_ = config.formatter;
            this.element = doc.createElement('div');
            this.element.classList.add(className$2());
            config.viewProps.bindClassModifiers(this.element);
            const textareaElem = doc.createElement('textarea');
            textareaElem.classList.add(className$2('i'));
            textareaElem.style.height = `calc(var(--bld-us) * ${config.lineCount})`;
            textareaElem.readOnly = true;
            config.viewProps.bindDisabled(textareaElem);
            this.element.appendChild(textareaElem);
            this.textareaElem_ = textareaElem;
            config.value.emitter.on('change', this.onValueUpdate_);
            this.value = config.value;
            this.update_();
        }
        update_() {
            const elem = this.textareaElem_;
            const shouldScroll = elem.scrollTop === elem.scrollHeight - elem.clientHeight;
            const lines = [];
            this.value.rawValue.forEach((value)=>{
                if (value !== undefined) lines.push(this.formatter_(value));
            });
            elem.textContent = lines.join('\n');
            if (shouldScroll) elem.scrollTop = elem.scrollHeight;
        }
        onValueUpdate_() {
            this.update_();
        }
    }
    class MultiLogController {
        constructor(doc, config){
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new MultiLogView(doc, {
                formatter: config.formatter,
                lineCount: config.lineCount,
                value: this.value,
                viewProps: this.viewProps
            });
        }
    }
    const className$1 = ClassName('sgl');
    class SingleLogView {
        constructor(doc, config){
            this.onValueUpdate_ = this.onValueUpdate_.bind(this);
            this.formatter_ = config.formatter;
            this.element = doc.createElement('div');
            this.element.classList.add(className$1());
            config.viewProps.bindClassModifiers(this.element);
            const inputElem = doc.createElement('input');
            inputElem.classList.add(className$1('i'));
            inputElem.readOnly = true;
            inputElem.type = 'text';
            config.viewProps.bindDisabled(inputElem);
            this.element.appendChild(inputElem);
            this.inputElement = inputElem;
            config.value.emitter.on('change', this.onValueUpdate_);
            this.value = config.value;
            this.update_();
        }
        update_() {
            const values = this.value.rawValue;
            const lastValue = values[values.length - 1];
            this.inputElement.value = lastValue !== undefined ? this.formatter_(lastValue) : '';
        }
        onValueUpdate_() {
            this.update_();
        }
    }
    class SingleLogController {
        constructor(doc, config){
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.view = new SingleLogView(doc, {
                formatter: config.formatter,
                value: this.value,
                viewProps: this.viewProps
            });
        }
    }
    const BooleanMonitorPlugin = {
        id: 'monitor-bool',
        type: 'monitor',
        accept: (value, params)=>{
            if (typeof value !== 'boolean') return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                lineCount: p.optional.number
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>boolFromUnknown
        },
        controller: (args)=>{
            var _a;
            if (args.value.rawValue.length === 1) return new SingleLogController(args.document, {
                formatter: BooleanFormatter,
                value: args.value,
                viewProps: args.viewProps
            });
            return new MultiLogController(args.document, {
                formatter: BooleanFormatter,
                lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount,
                value: args.value,
                viewProps: args.viewProps
            });
        }
    };
    const className = ClassName('grl');
    class GraphLogView {
        constructor(doc, config){
            this.onCursorChange_ = this.onCursorChange_.bind(this);
            this.onValueUpdate_ = this.onValueUpdate_.bind(this);
            this.element = doc.createElement('div');
            this.element.classList.add(className());
            config.viewProps.bindClassModifiers(this.element);
            this.formatter_ = config.formatter;
            this.props_ = config.props;
            this.cursor_ = config.cursor;
            this.cursor_.emitter.on('change', this.onCursorChange_);
            const svgElem = doc.createElementNS(SVG_NS, 'svg');
            svgElem.classList.add(className('g'));
            svgElem.style.height = `calc(var(--bld-us) * ${config.lineCount})`;
            this.element.appendChild(svgElem);
            this.svgElem_ = svgElem;
            const lineElem = doc.createElementNS(SVG_NS, 'polyline');
            this.svgElem_.appendChild(lineElem);
            this.lineElem_ = lineElem;
            const tooltipElem = doc.createElement('div');
            tooltipElem.classList.add(className('t'), ClassName('tt')());
            this.element.appendChild(tooltipElem);
            this.tooltipElem_ = tooltipElem;
            config.value.emitter.on('change', this.onValueUpdate_);
            this.value = config.value;
            this.update_();
        }
        get graphElement() {
            return this.svgElem_;
        }
        update_() {
            const bounds = this.svgElem_.getBoundingClientRect();
            const maxIndex = this.value.rawValue.length - 1;
            const min = this.props_.get('minValue');
            const max = this.props_.get('maxValue');
            const points = [];
            this.value.rawValue.forEach((v, index)=>{
                if (v === undefined) return;
                const x = mapRange(index, 0, maxIndex, 0, bounds.width);
                const y = mapRange(v, min, max, bounds.height, 0);
                points.push([
                    x,
                    y
                ].join(','));
            });
            this.lineElem_.setAttributeNS(null, 'points', points.join(' '));
            const tooltipElem = this.tooltipElem_;
            const value = this.value.rawValue[this.cursor_.rawValue];
            if (value === undefined) {
                tooltipElem.classList.remove(className('t', 'a'));
                return;
            }
            const tx = mapRange(this.cursor_.rawValue, 0, maxIndex, 0, bounds.width);
            const ty = mapRange(value, min, max, bounds.height, 0);
            tooltipElem.style.left = `${tx}px`;
            tooltipElem.style.top = `${ty}px`;
            tooltipElem.textContent = `${this.formatter_(value)}`;
            if (!tooltipElem.classList.contains(className('t', 'a'))) {
                tooltipElem.classList.add(className('t', 'a'), className('t', 'in'));
                forceReflow(tooltipElem);
                tooltipElem.classList.remove(className('t', 'in'));
            }
        }
        onValueUpdate_() {
            this.update_();
        }
        onCursorChange_() {
            this.update_();
        }
    }
    class GraphLogController {
        constructor(doc, config){
            this.onGraphMouseMove_ = this.onGraphMouseMove_.bind(this);
            this.onGraphMouseLeave_ = this.onGraphMouseLeave_.bind(this);
            this.onGraphPointerDown_ = this.onGraphPointerDown_.bind(this);
            this.onGraphPointerMove_ = this.onGraphPointerMove_.bind(this);
            this.onGraphPointerUp_ = this.onGraphPointerUp_.bind(this);
            this.props_ = config.props;
            this.value = config.value;
            this.viewProps = config.viewProps;
            this.cursor_ = createValue(-1);
            this.view = new GraphLogView(doc, {
                cursor: this.cursor_,
                formatter: config.formatter,
                lineCount: config.lineCount,
                props: this.props_,
                value: this.value,
                viewProps: this.viewProps
            });
            if (!supportsTouch(doc)) {
                this.view.element.addEventListener('mousemove', this.onGraphMouseMove_);
                this.view.element.addEventListener('mouseleave', this.onGraphMouseLeave_);
            } else {
                const ph = new PointerHandler(this.view.element);
                ph.emitter.on('down', this.onGraphPointerDown_);
                ph.emitter.on('move', this.onGraphPointerMove_);
                ph.emitter.on('up', this.onGraphPointerUp_);
            }
        }
        onGraphMouseLeave_() {
            this.cursor_.rawValue = -1;
        }
        onGraphMouseMove_(ev) {
            const bounds = this.view.element.getBoundingClientRect();
            this.cursor_.rawValue = Math.floor(mapRange(ev.offsetX, 0, bounds.width, 0, this.value.rawValue.length));
        }
        onGraphPointerDown_(ev) {
            this.onGraphPointerMove_(ev);
        }
        onGraphPointerMove_(ev) {
            if (!ev.data.point) {
                this.cursor_.rawValue = -1;
                return;
            }
            this.cursor_.rawValue = Math.floor(mapRange(ev.data.point.x, 0, ev.data.bounds.width, 0, this.value.rawValue.length));
        }
        onGraphPointerUp_() {
            this.cursor_.rawValue = -1;
        }
    }
    function createFormatter(params) {
        return 'format' in params && !isEmpty(params.format) ? params.format : createNumberFormatter(2);
    }
    function createTextMonitor(args) {
        var _a;
        if (args.value.rawValue.length === 1) return new SingleLogController(args.document, {
            formatter: createFormatter(args.params),
            value: args.value,
            viewProps: args.viewProps
        });
        return new MultiLogController(args.document, {
            formatter: createFormatter(args.params),
            lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount,
            value: args.value,
            viewProps: args.viewProps
        });
    }
    function createGraphMonitor(args) {
        var _a, _b, _c;
        return new GraphLogController(args.document, {
            formatter: createFormatter(args.params),
            lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount,
            props: ValueMap.fromObject({
                maxValue: (_b = 'max' in args.params ? args.params.max : null) !== null && _b !== void 0 ? _b : 100,
                minValue: (_c = 'min' in args.params ? args.params.min : null) !== null && _c !== void 0 ? _c : 0
            }),
            value: args.value,
            viewProps: args.viewProps
        });
    }
    function shouldShowGraph(params) {
        return 'view' in params && params.view === 'graph';
    }
    const NumberMonitorPlugin = {
        id: 'monitor-number',
        type: 'monitor',
        accept: (value, params)=>{
            if (typeof value !== 'number') return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                format: p.optional.function,
                lineCount: p.optional.number,
                max: p.optional.number,
                min: p.optional.number,
                view: p.optional.string
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            defaultBufferSize: (params)=>shouldShowGraph(params) ? 64 : 1,
            reader: (_args)=>numberFromUnknown
        },
        controller: (args)=>{
            if (shouldShowGraph(args.params)) return createGraphMonitor(args);
            return createTextMonitor(args);
        }
    };
    const StringMonitorPlugin = {
        id: 'monitor-string',
        type: 'monitor',
        accept: (value, params)=>{
            if (typeof value !== 'string') return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                lineCount: p.optional.number,
                multiline: p.optional.boolean
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>stringFromUnknown
        },
        controller: (args)=>{
            var _a;
            const value = args.value;
            const multiline = value.rawValue.length > 1 || 'multiline' in args.params && args.params.multiline;
            if (multiline) return new MultiLogController(args.document, {
                formatter: formatString,
                lineCount: (_a = args.params.lineCount) !== null && _a !== void 0 ? _a : Constants.monitor.defaultLineCount,
                value: value,
                viewProps: args.viewProps
            });
            return new SingleLogController(args.document, {
                formatter: formatString,
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    function createInputBindingController(plugin, args) {
        var _a;
        const result = plugin.accept(args.target.read(), args.params);
        if (isEmpty(result)) return null;
        const p = ParamsParsers;
        const valueArgs = {
            target: args.target,
            initialValue: result.initialValue,
            params: result.params
        };
        const reader = plugin.binding.reader(valueArgs);
        const constraint = plugin.binding.constraint ? plugin.binding.constraint(valueArgs) : undefined;
        const value = createValue(reader(result.initialValue), {
            constraint: constraint,
            equals: plugin.binding.equals
        });
        const binding = new InputBinding({
            reader: reader,
            target: args.target,
            value: value,
            writer: plugin.binding.writer(valueArgs)
        });
        const disabled = p.optional.boolean(args.params.disabled).value;
        const hidden = p.optional.boolean(args.params.hidden).value;
        const controller = plugin.controller({
            constraint: constraint,
            document: args.document,
            initialValue: result.initialValue,
            params: result.params,
            value: binding.value,
            viewProps: ViewProps.create({
                disabled: disabled,
                hidden: hidden
            })
        });
        return new InputBindingController(args.document, {
            binding: binding,
            blade: createBlade(),
            props: ValueMap.fromObject({
                label: 'label' in args.params ? (_a = p.optional.string(args.params.label).value) !== null && _a !== void 0 ? _a : null : args.target.key
            }),
            valueController: controller
        });
    }
    function createTicker(document, interval) {
        return interval === 0 ? new ManualTicker() : new IntervalTicker(document, interval !== null && interval !== void 0 ? interval : Constants.monitor.defaultInterval);
    }
    function createMonitorBindingController(plugin, args) {
        var _a, _b, _c;
        const p = ParamsParsers;
        const result = plugin.accept(args.target.read(), args.params);
        if (isEmpty(result)) return null;
        const bindingArgs = {
            target: args.target,
            initialValue: result.initialValue,
            params: result.params
        };
        const reader = plugin.binding.reader(bindingArgs);
        const bufferSize = (_b = (_a = p.optional.number(args.params.bufferSize).value) !== null && _a !== void 0 ? _a : plugin.binding.defaultBufferSize && plugin.binding.defaultBufferSize(result.params)) !== null && _b !== void 0 ? _b : 1;
        const interval = p.optional.number(args.params.interval).value;
        const binding = new MonitorBinding({
            reader: reader,
            target: args.target,
            ticker: createTicker(args.document, interval),
            value: initializeBuffer(bufferSize)
        });
        const disabled = p.optional.boolean(args.params.disabled).value;
        const hidden = p.optional.boolean(args.params.hidden).value;
        const controller = plugin.controller({
            document: args.document,
            params: result.params,
            value: binding.value,
            viewProps: ViewProps.create({
                disabled: disabled,
                hidden: hidden
            })
        });
        return new MonitorBindingController(args.document, {
            binding: binding,
            blade: createBlade(),
            props: ValueMap.fromObject({
                label: 'label' in args.params ? (_c = p.optional.string(args.params.label).value) !== null && _c !== void 0 ? _c : null : args.target.key
            }),
            valueController: controller
        });
    }
    class PluginPool {
        constructor(){
            this.pluginsMap_ = {
                blades: [],
                inputs: [],
                monitors: []
            };
        }
        getAll() {
            return [
                ...this.pluginsMap_.blades,
                ...this.pluginsMap_.inputs,
                ...this.pluginsMap_.monitors
            ];
        }
        register(r) {
            if (r.type === 'blade') this.pluginsMap_.blades.unshift(r);
            else if (r.type === 'input') this.pluginsMap_.inputs.unshift(r);
            else if (r.type === 'monitor') this.pluginsMap_.monitors.unshift(r);
        }
        createInput(document, target, params) {
            const initialValue = target.read();
            if (isEmpty(initialValue)) throw new TpError({
                context: {
                    key: target.key
                },
                type: 'nomatchingcontroller'
            });
            const bc = this.pluginsMap_.inputs.reduce((result, plugin)=>result !== null && result !== void 0 ? result : createInputBindingController(plugin, {
                    document: document,
                    target: target,
                    params: params
                }), null);
            if (bc) return bc;
            throw new TpError({
                context: {
                    key: target.key
                },
                type: 'nomatchingcontroller'
            });
        }
        createMonitor(document, target, params) {
            const bc = this.pluginsMap_.monitors.reduce((result, plugin)=>result !== null && result !== void 0 ? result : createMonitorBindingController(plugin, {
                    document: document,
                    params: params,
                    target: target
                }), null);
            if (bc) return bc;
            throw new TpError({
                context: {
                    key: target.key
                },
                type: 'nomatchingcontroller'
            });
        }
        createBlade(document, params) {
            const bc = this.pluginsMap_.blades.reduce((result, plugin)=>result !== null && result !== void 0 ? result : createBladeController(plugin, {
                    document: document,
                    params: params
                }), null);
            if (!bc) throw new TpError({
                type: 'nomatchingview',
                context: {
                    params: params
                }
            });
            return bc;
        }
        createBladeApi(bc) {
            if (bc instanceof InputBindingController) return new InputBindingApi(bc);
            if (bc instanceof MonitorBindingController) return new MonitorBindingApi(bc);
            if (bc instanceof RackController) return new RackApi(bc, this);
            const api = this.pluginsMap_.blades.reduce((result, plugin)=>result !== null && result !== void 0 ? result : plugin.api({
                    controller: bc,
                    pool: this
                }), null);
            if (!api) throw TpError.shouldNeverHappen();
            return api;
        }
    }
    function createDefaultPluginPool() {
        const pool = new PluginPool();
        [
            Point2dInputPlugin,
            Point3dInputPlugin,
            Point4dInputPlugin,
            StringInputPlugin,
            NumberInputPlugin,
            StringColorInputPlugin,
            ObjectColorInputPlugin,
            NumberColorInputPlugin,
            BooleanInputPlugin,
            BooleanMonitorPlugin,
            StringMonitorPlugin,
            NumberMonitorPlugin,
            ButtonBladePlugin,
            FolderBladePlugin,
            SeparatorBladePlugin,
            TabBladePlugin
        ].forEach((p)=>{
            pool.register(p);
        });
        return pool;
    }
    function point2dFromUnknown(value) {
        return Point2d.isObject(value) ? new Point2d(value.x, value.y) : new Point2d();
    }
    function writePoint2d(target, value) {
        target.writeProperty('x', value.x);
        target.writeProperty('y', value.y);
    }
    function createDimensionConstraint(params, initialValue) {
        if (!params) return undefined;
        const constraints = [];
        const cs = createStepConstraint(params, initialValue);
        if (cs) constraints.push(cs);
        const rs = createRangeConstraint(params);
        if (rs) constraints.push(rs);
        return new CompositeConstraint(constraints);
    }
    function createConstraint(params, initialValue) {
        return new PointNdConstraint({
            assembly: Point2dAssembly,
            components: [
                createDimensionConstraint('x' in params ? params.x : undefined, initialValue.x),
                createDimensionConstraint('y' in params ? params.y : undefined, initialValue.y)
            ]
        });
    }
    function getSuitableMaxDimensionValue(constraint, rawValue) {
        const [min, max] = constraint ? findNumberRange(constraint) : [];
        if (!isEmpty(min) || !isEmpty(max)) return Math.max(Math.abs(min !== null && min !== void 0 ? min : 0), Math.abs(max !== null && max !== void 0 ? max : 0));
        const step = getBaseStep(constraint);
        return Math.max(Math.abs(step) * 10, Math.abs(rawValue) * 10);
    }
    function getSuitableMaxValue(initialValue, constraint) {
        const xc = constraint instanceof PointNdConstraint ? constraint.components[0] : undefined;
        const yc = constraint instanceof PointNdConstraint ? constraint.components[1] : undefined;
        const xr = getSuitableMaxDimensionValue(xc, initialValue.x);
        const yr = getSuitableMaxDimensionValue(yc, initialValue.y);
        return Math.max(xr, yr);
    }
    function createAxis(initialValue, constraint) {
        return {
            baseStep: getBaseStep(constraint),
            constraint: constraint,
            textProps: ValueMap.fromObject({
                draggingScale: getSuitableDraggingScale(constraint, initialValue),
                formatter: createNumberFormatter(getSuitableDecimalDigits(constraint, initialValue))
            })
        };
    }
    function shouldInvertY(params) {
        if (!('y' in params)) return false;
        const yParams = params.y;
        if (!yParams) return false;
        return 'inverted' in yParams ? !!yParams.inverted : false;
    }
    const Point2dInputPlugin = {
        id: 'input-point2d',
        type: 'input',
        accept: (value, params)=>{
            if (!Point2d.isObject(value)) return null;
            const p = ParamsParsers;
            const result = parseParams(params, {
                expanded: p.optional.boolean,
                picker: p.optional.custom(parsePickerLayout),
                x: p.optional.custom(parsePointDimensionParams),
                y: p.optional.object({
                    inverted: p.optional.boolean,
                    max: p.optional.number,
                    min: p.optional.number,
                    step: p.optional.number
                })
            });
            return result ? {
                initialValue: value,
                params: result
            } : null;
        },
        binding: {
            reader: (_args)=>point2dFromUnknown,
            constraint: (args)=>createConstraint(args.params, args.initialValue),
            equals: Point2d.equals,
            writer: (_args)=>writePoint2d
        },
        controller: (args)=>{
            const doc = args.document;
            const value = args.value;
            const c = args.constraint;
            if (!(c instanceof PointNdConstraint)) throw TpError.shouldNeverHappen();
            const expanded = 'expanded' in args.params ? args.params.expanded : undefined;
            const picker = 'picker' in args.params ? args.params.picker : undefined;
            return new Point2dController(doc, {
                axes: [
                    createAxis(value.rawValue.x, c.components[0]),
                    createAxis(value.rawValue.y, c.components[1])
                ],
                expanded: expanded !== null && expanded !== void 0 ? expanded : false,
                invertsY: shouldInvertY(args.params),
                maxValue: getSuitableMaxValue(value.rawValue, c),
                parser: parseNumber,
                pickerLayout: picker !== null && picker !== void 0 ? picker : 'popup',
                value: value,
                viewProps: args.viewProps
            });
        }
    };
    class ListApi extends BladeApi {
        constructor(controller){
            super(controller);
            this.emitter_ = new Emitter();
            this.controller_.valueController.value.emitter.on('change', (ev)=>{
                this.emitter_.emit('change', {
                    event: new TpChangeEvent(this, ev.rawValue)
                });
            });
        }
        get label() {
            return this.controller_.props.get('label');
        }
        set label(label) {
            this.controller_.props.set('label', label);
        }
        get options() {
            return this.controller_.valueController.props.get('options');
        }
        set options(options) {
            this.controller_.valueController.props.set('options', options);
        }
        get value() {
            return this.controller_.valueController.value.rawValue;
        }
        set value(value) {
            this.controller_.valueController.value.rawValue = value;
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
    }
    class SliderApi extends BladeApi {
        constructor(controller){
            super(controller);
            this.emitter_ = new Emitter();
            this.controller_.valueController.value.emitter.on('change', (ev)=>{
                this.emitter_.emit('change', {
                    event: new TpChangeEvent(this, ev.rawValue)
                });
            });
        }
        get label() {
            return this.controller_.props.get('label');
        }
        set label(label) {
            this.controller_.props.set('label', label);
        }
        get maxValue() {
            return this.controller_.valueController.sliderController.props.get('maxValue');
        }
        set maxValue(maxValue) {
            this.controller_.valueController.sliderController.props.set('maxValue', maxValue);
        }
        get minValue() {
            return this.controller_.valueController.sliderController.props.get('minValue');
        }
        set minValue(minValue) {
            this.controller_.valueController.sliderController.props.set('minValue', minValue);
        }
        get value() {
            return this.controller_.valueController.value.rawValue;
        }
        set value(value) {
            this.controller_.valueController.value.rawValue = value;
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
    }
    class TextApi extends BladeApi {
        constructor(controller){
            super(controller);
            this.emitter_ = new Emitter();
            this.controller_.valueController.value.emitter.on('change', (ev)=>{
                this.emitter_.emit('change', {
                    event: new TpChangeEvent(this, ev.rawValue)
                });
            });
        }
        get label() {
            return this.controller_.props.get('label');
        }
        set label(label) {
            this.controller_.props.set('label', label);
        }
        get formatter() {
            return this.controller_.valueController.props.get('formatter');
        }
        set formatter(formatter) {
            this.controller_.valueController.props.set('formatter', formatter);
        }
        get value() {
            return this.controller_.valueController.value.rawValue;
        }
        set value(value) {
            this.controller_.valueController.value.rawValue = value;
        }
        on(eventName, handler) {
            const bh = handler.bind(this);
            this.emitter_.on(eventName, (ev)=>{
                bh(ev.event);
            });
            return this;
        }
    }
    const ListBladePlugin = function() {
        return {
            id: 'list',
            type: 'blade',
            accept (params) {
                const p = ParamsParsers;
                const result = parseParams(params, {
                    options: p.required.custom(parseListOptions),
                    value: p.required.raw,
                    view: p.required.constant('list'),
                    label: p.optional.string
                });
                return result ? {
                    params: result
                } : null;
            },
            controller (args) {
                const lc = new ListConstraint(normalizeListOptions(args.params.options));
                const value = createValue(args.params.value, {
                    constraint: lc
                });
                const ic = new ListController(args.document, {
                    props: new ValueMap({
                        options: lc.values.value('options')
                    }),
                    value: value,
                    viewProps: args.viewProps
                });
                return new LabeledValueController(args.document, {
                    blade: args.blade,
                    props: ValueMap.fromObject({
                        label: args.params.label
                    }),
                    valueController: ic
                });
            },
            api (args) {
                if (!(args.controller instanceof LabeledValueController)) return null;
                if (!(args.controller.valueController instanceof ListController)) return null;
                return new ListApi(args.controller);
            }
        };
    }();
    /**
     * @hidden
     */ function exportPresetJson(targets) {
        return targets.reduce((result, target)=>{
            return Object.assign(result, {
                [target.presetKey]: target.read()
            });
        }, {});
    }
    /**
     * @hidden
     */ function importPresetJson(bindings, preset) {
        bindings.forEach((binding)=>{
            const value = preset[binding.target.presetKey];
            if (value !== undefined) binding.writer(binding.target, binding.reader(value));
        });
    }
    class RootApi extends FolderApi {
        /**
         * @hidden
         */ constructor(controller, pool){
            super(controller, pool);
        }
        get element() {
            return this.controller_.view.element;
        }
        /**
         * Imports a preset of all inputs.
         * @param preset The preset object to import.
         */ importPreset(preset) {
            const bindings = this.controller_.rackController.rack.find(InputBindingController).map((ibc)=>{
                return ibc.binding;
            });
            importPresetJson(bindings, preset);
            this.refresh();
        }
        /**
         * Exports a preset of all inputs.
         * @return An exported preset object.
         */ exportPreset() {
            const targets = this.controller_.rackController.rack.find(InputBindingController).map((ibc)=>{
                return ibc.binding.target;
            });
            return exportPresetJson(targets);
        }
        /**
         * Refreshes all bindings of the pane.
         */ refresh() {
            // Force-read all input bindings
            this.controller_.rackController.rack.find(InputBindingController).forEach((ibc)=>{
                ibc.binding.read();
            });
            // Force-read all monitor bindings
            this.controller_.rackController.rack.find(MonitorBindingController).forEach((mbc)=>{
                mbc.binding.read();
            });
        }
    }
    class RootController extends FolderController {
        constructor(doc, config){
            super(doc, {
                expanded: config.expanded,
                blade: config.blade,
                props: config.props,
                root: true,
                viewProps: config.viewProps
            });
        }
    }
    const SliderBladePlugin = {
        id: 'slider',
        type: 'blade',
        accept (params) {
            const p = ParamsParsers;
            const result = parseParams(params, {
                max: p.required.number,
                min: p.required.number,
                view: p.required.constant('slider'),
                format: p.optional.function,
                label: p.optional.string,
                value: p.optional.number
            });
            return result ? {
                params: result
            } : null;
        },
        controller (args) {
            var _a, _b;
            const initialValue = (_a = args.params.value) !== null && _a !== void 0 ? _a : 0;
            const drc = new DefiniteRangeConstraint({
                max: args.params.max,
                min: args.params.min
            });
            const vc = new SliderTextController(args.document, {
                baseStep: 1,
                parser: parseNumber,
                sliderProps: new ValueMap({
                    maxValue: drc.values.value('max'),
                    minValue: drc.values.value('min')
                }),
                textProps: ValueMap.fromObject({
                    draggingScale: getSuitableDraggingScale(undefined, initialValue),
                    formatter: (_b = args.params.format) !== null && _b !== void 0 ? _b : numberToString
                }),
                value: createValue(initialValue, {
                    constraint: drc
                }),
                viewProps: args.viewProps
            });
            return new LabeledValueController(args.document, {
                blade: args.blade,
                props: ValueMap.fromObject({
                    label: args.params.label
                }),
                valueController: vc
            });
        },
        api (args) {
            if (!(args.controller instanceof LabeledValueController)) return null;
            if (!(args.controller.valueController instanceof SliderTextController)) return null;
            return new SliderApi(args.controller);
        }
    };
    const TextBladePlugin = function() {
        return {
            id: 'text',
            type: 'blade',
            accept (params) {
                const p = ParamsParsers;
                const result = parseParams(params, {
                    parse: p.required.function,
                    value: p.required.raw,
                    view: p.required.constant('text'),
                    format: p.optional.function,
                    label: p.optional.string
                });
                return result ? {
                    params: result
                } : null;
            },
            controller (args) {
                var _a;
                const ic = new TextController(args.document, {
                    parser: args.params.parse,
                    props: ValueMap.fromObject({
                        formatter: (_a = args.params.format) !== null && _a !== void 0 ? _a : (v)=>String(v)
                    }),
                    value: createValue(args.params.value),
                    viewProps: args.viewProps
                });
                return new LabeledValueController(args.document, {
                    blade: args.blade,
                    props: ValueMap.fromObject({
                        label: args.params.label
                    }),
                    valueController: ic
                });
            },
            api (args) {
                if (!(args.controller instanceof LabeledValueController)) return null;
                if (!(args.controller.valueController instanceof TextController)) return null;
                return new TextApi(args.controller);
            }
        };
    }();
    function createDefaultWrapperElement(doc) {
        const elem = doc.createElement('div');
        elem.classList.add(ClassName('dfw')());
        if (doc.body) doc.body.appendChild(elem);
        return elem;
    }
    function embedStyle(doc, id, css) {
        if (doc.querySelector(`style[data-tp-style=${id}]`)) return;
        const styleElem = doc.createElement('style');
        styleElem.dataset.tpStyle = id;
        styleElem.textContent = css;
        doc.head.appendChild(styleElem);
    }
    /**
     * The root pane of Tweakpane.
     */ class Pane extends RootApi {
        constructor(opt_config){
            var _a, _b;
            const config = opt_config !== null && opt_config !== void 0 ? opt_config : {};
            const doc = (_a = config.document) !== null && _a !== void 0 ? _a : getWindowDocument();
            const pool = createDefaultPluginPool();
            const rootController = new RootController(doc, {
                expanded: config.expanded,
                blade: createBlade(),
                props: ValueMap.fromObject({
                    title: config.title
                }),
                viewProps: ViewProps.create()
            });
            super(rootController, pool);
            this.pool_ = pool;
            this.containerElem_ = (_b = config.container) !== null && _b !== void 0 ? _b : createDefaultWrapperElement(doc);
            this.containerElem_.appendChild(this.element);
            this.doc_ = doc;
            this.usesDefaultWrapper_ = !config.container;
            this.setUpDefaultPlugins_();
        }
        get document() {
            if (!this.doc_) throw TpError.alreadyDisposed();
            return this.doc_;
        }
        dispose() {
            const containerElem = this.containerElem_;
            if (!containerElem) throw TpError.alreadyDisposed();
            if (this.usesDefaultWrapper_) {
                const parentElem = containerElem.parentElement;
                if (parentElem) parentElem.removeChild(containerElem);
            }
            this.containerElem_ = null;
            this.doc_ = null;
            super.dispose();
        }
        registerPlugin(bundle) {
            const plugins = 'plugin' in bundle ? [
                bundle.plugin
            ] : 'plugins' in bundle ? bundle.plugins : [];
            plugins.forEach((p)=>{
                this.pool_.register(p);
                this.embedPluginStyle_(p);
            });
        }
        embedPluginStyle_(plugin) {
            if (plugin.css) embedStyle(this.document, `plugin-${plugin.id}`, plugin.css);
        }
        setUpDefaultPlugins_() {
            // NOTE: This string literal will be replaced with the default CSS by Rollup at the compilation time
            embedStyle(this.document, 'default', '.tp-tbiv_b,.tp-coltxtv_ms,.tp-ckbv_i,.tp-rotv_b,.tp-fldv_b,.tp-mllv_i,.tp-sglv_i,.tp-grlv_g,.tp-txtv_i,.tp-p2dpv_p,.tp-colswv_sw,.tp-p2dv_b,.tp-btnv_b,.tp-lstv_s{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:rgba(0,0,0,0);border-width:0;font-family:inherit;font-size:inherit;font-weight:inherit;margin:0;outline:none;padding:0}.tp-p2dv_b,.tp-btnv_b,.tp-lstv_s{background-color:var(--btn-bg);border-radius:var(--elm-br);color:var(--btn-fg);cursor:pointer;display:block;font-weight:bold;height:var(--bld-us);line-height:var(--bld-us);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.tp-p2dv_b:hover,.tp-btnv_b:hover,.tp-lstv_s:hover{background-color:var(--btn-bg-h)}.tp-p2dv_b:focus,.tp-btnv_b:focus,.tp-lstv_s:focus{background-color:var(--btn-bg-f)}.tp-p2dv_b:active,.tp-btnv_b:active,.tp-lstv_s:active{background-color:var(--btn-bg-a)}.tp-p2dv_b:disabled,.tp-btnv_b:disabled,.tp-lstv_s:disabled{opacity:.5}.tp-txtv_i,.tp-p2dpv_p,.tp-colswv_sw{background-color:var(--in-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--in-fg);font-family:inherit;height:var(--bld-us);line-height:var(--bld-us);min-width:0;width:100%}.tp-txtv_i:hover,.tp-p2dpv_p:hover,.tp-colswv_sw:hover{background-color:var(--in-bg-h)}.tp-txtv_i:focus,.tp-p2dpv_p:focus,.tp-colswv_sw:focus{background-color:var(--in-bg-f)}.tp-txtv_i:active,.tp-p2dpv_p:active,.tp-colswv_sw:active{background-color:var(--in-bg-a)}.tp-txtv_i:disabled,.tp-p2dpv_p:disabled,.tp-colswv_sw:disabled{opacity:.5}.tp-mllv_i,.tp-sglv_i,.tp-grlv_g{background-color:var(--mo-bg);border-radius:var(--elm-br);box-sizing:border-box;color:var(--mo-fg);height:var(--bld-us);scrollbar-color:currentColor rgba(0,0,0,0);scrollbar-width:thin;width:100%}.tp-mllv_i::-webkit-scrollbar,.tp-sglv_i::-webkit-scrollbar,.tp-grlv_g::-webkit-scrollbar{height:8px;width:8px}.tp-mllv_i::-webkit-scrollbar-corner,.tp-sglv_i::-webkit-scrollbar-corner,.tp-grlv_g::-webkit-scrollbar-corner{background-color:rgba(0,0,0,0)}.tp-mllv_i::-webkit-scrollbar-thumb,.tp-sglv_i::-webkit-scrollbar-thumb,.tp-grlv_g::-webkit-scrollbar-thumb{background-clip:padding-box;background-color:currentColor;border:rgba(0,0,0,0) solid 2px;border-radius:4px}.tp-rotv{--font-family: var(--tp-font-family, Roboto Mono, Source Code Pro, Menlo, Courier, monospace);--bs-br: var(--tp-base-border-radius, 6px);--cnt-h-p: var(--tp-container-horizontal-padding, 4px);--cnt-v-p: var(--tp-container-vertical-padding, 4px);--elm-br: var(--tp-element-border-radius, 2px);--bld-s: var(--tp-blade-spacing, 4px);--bld-us: var(--tp-blade-unit-size, 20px);--bs-bg: var(--tp-base-background-color, hsl(230, 7%, 17%));--bs-sh: var(--tp-base-shadow-color, rgba(0, 0, 0, 0.2));--btn-bg: var(--tp-button-background-color, hsl(230, 7%, 70%));--btn-bg-a: var(--tp-button-background-color-active, #d6d7db);--btn-bg-f: var(--tp-button-background-color-focus, #c8cad0);--btn-bg-h: var(--tp-button-background-color-hover, #bbbcc4);--btn-fg: var(--tp-button-foreground-color, hsl(230, 7%, 17%));--cnt-bg: var(--tp-container-background-color, rgba(187, 188, 196, 0.1));--cnt-bg-a: var(--tp-container-background-color-active, rgba(187, 188, 196, 0.25));--cnt-bg-f: var(--tp-container-background-color-focus, rgba(187, 188, 196, 0.2));--cnt-bg-h: var(--tp-container-background-color-hover, rgba(187, 188, 196, 0.15));--cnt-fg: var(--tp-container-foreground-color, hsl(230, 7%, 75%));--in-bg: var(--tp-input-background-color, rgba(187, 188, 196, 0.1));--in-bg-a: var(--tp-input-background-color-active, rgba(187, 188, 196, 0.25));--in-bg-f: var(--tp-input-background-color-focus, rgba(187, 188, 196, 0.2));--in-bg-h: var(--tp-input-background-color-hover, rgba(187, 188, 196, 0.15));--in-fg: var(--tp-input-foreground-color, hsl(230, 7%, 75%));--lbl-fg: var(--tp-label-foreground-color, rgba(187, 188, 196, 0.7));--mo-bg: var(--tp-monitor-background-color, rgba(0, 0, 0, 0.2));--mo-fg: var(--tp-monitor-foreground-color, rgba(187, 188, 196, 0.7));--grv-fg: var(--tp-groove-foreground-color, rgba(187, 188, 196, 0.1))}.tp-rotv_c>.tp-cntv.tp-v-lst,.tp-tabv_c .tp-brkv>.tp-cntv.tp-v-lst,.tp-fldv_c>.tp-cntv.tp-v-lst{margin-bottom:calc(-1*var(--cnt-v-p))}.tp-rotv_c>.tp-fldv.tp-v-lst .tp-fldv_c,.tp-tabv_c .tp-brkv>.tp-fldv.tp-v-lst .tp-fldv_c,.tp-fldv_c>.tp-fldv.tp-v-lst .tp-fldv_c{border-bottom-left-radius:0}.tp-rotv_c>.tp-fldv.tp-v-lst .tp-fldv_b,.tp-tabv_c .tp-brkv>.tp-fldv.tp-v-lst .tp-fldv_b,.tp-fldv_c>.tp-fldv.tp-v-lst .tp-fldv_b{border-bottom-left-radius:0}.tp-rotv_c>*:not(.tp-v-fst),.tp-tabv_c .tp-brkv>*:not(.tp-v-fst),.tp-fldv_c>*:not(.tp-v-fst){margin-top:var(--bld-s)}.tp-rotv_c>.tp-sprv:not(.tp-v-fst),.tp-tabv_c .tp-brkv>.tp-sprv:not(.tp-v-fst),.tp-fldv_c>.tp-sprv:not(.tp-v-fst),.tp-rotv_c>.tp-cntv:not(.tp-v-fst),.tp-tabv_c .tp-brkv>.tp-cntv:not(.tp-v-fst),.tp-fldv_c>.tp-cntv:not(.tp-v-fst){margin-top:var(--cnt-v-p)}.tp-rotv_c>.tp-sprv+*:not(.tp-v-hidden),.tp-tabv_c .tp-brkv>.tp-sprv+*:not(.tp-v-hidden),.tp-fldv_c>.tp-sprv+*:not(.tp-v-hidden),.tp-rotv_c>.tp-cntv+*:not(.tp-v-hidden),.tp-tabv_c .tp-brkv>.tp-cntv+*:not(.tp-v-hidden),.tp-fldv_c>.tp-cntv+*:not(.tp-v-hidden){margin-top:var(--cnt-v-p)}.tp-rotv_c>.tp-sprv:not(.tp-v-hidden)+.tp-sprv,.tp-tabv_c .tp-brkv>.tp-sprv:not(.tp-v-hidden)+.tp-sprv,.tp-fldv_c>.tp-sprv:not(.tp-v-hidden)+.tp-sprv,.tp-rotv_c>.tp-cntv:not(.tp-v-hidden)+.tp-cntv,.tp-tabv_c .tp-brkv>.tp-cntv:not(.tp-v-hidden)+.tp-cntv,.tp-fldv_c>.tp-cntv:not(.tp-v-hidden)+.tp-cntv{margin-top:0}.tp-tabv_c .tp-brkv>.tp-cntv,.tp-fldv_c>.tp-cntv{margin-left:4px}.tp-tabv_c .tp-brkv>.tp-fldv>.tp-fldv_b,.tp-fldv_c>.tp-fldv>.tp-fldv_b{border-top-left-radius:var(--elm-br);border-bottom-left-radius:var(--elm-br)}.tp-tabv_c .tp-brkv>.tp-fldv.tp-fldv-expanded>.tp-fldv_b,.tp-fldv_c>.tp-fldv.tp-fldv-expanded>.tp-fldv_b{border-bottom-left-radius:0}.tp-tabv_c .tp-brkv .tp-fldv>.tp-fldv_c,.tp-fldv_c .tp-fldv>.tp-fldv_c{border-bottom-left-radius:var(--elm-br)}.tp-tabv_c .tp-brkv>.tp-cntv+.tp-fldv>.tp-fldv_b,.tp-fldv_c>.tp-cntv+.tp-fldv>.tp-fldv_b{border-top-left-radius:0}.tp-tabv_c .tp-brkv>.tp-cntv+.tp-tabv>.tp-tabv_t,.tp-fldv_c>.tp-cntv+.tp-tabv>.tp-tabv_t{border-top-left-radius:0}.tp-tabv_c .tp-brkv>.tp-tabv>.tp-tabv_t,.tp-fldv_c>.tp-tabv>.tp-tabv_t{border-top-left-radius:var(--elm-br)}.tp-tabv_c .tp-brkv .tp-tabv>.tp-tabv_c,.tp-fldv_c .tp-tabv>.tp-tabv_c{border-bottom-left-radius:var(--elm-br)}.tp-rotv_b,.tp-fldv_b{background-color:var(--cnt-bg);color:var(--cnt-fg);cursor:pointer;display:block;height:calc(var(--bld-us) + 4px);line-height:calc(var(--bld-us) + 4px);overflow:hidden;padding-left:var(--cnt-h-p);padding-right:calc(4px + var(--bld-us) + var(--cnt-h-p));position:relative;text-align:left;text-overflow:ellipsis;white-space:nowrap;width:100%;transition:border-radius .2s ease-in-out .2s}.tp-rotv_b:hover,.tp-fldv_b:hover{background-color:var(--cnt-bg-h)}.tp-rotv_b:focus,.tp-fldv_b:focus{background-color:var(--cnt-bg-f)}.tp-rotv_b:active,.tp-fldv_b:active{background-color:var(--cnt-bg-a)}.tp-rotv_b:disabled,.tp-fldv_b:disabled{opacity:.5}.tp-rotv_m,.tp-fldv_m{background:linear-gradient(to left, var(--cnt-fg), var(--cnt-fg) 2px, transparent 2px, transparent 4px, var(--cnt-fg) 4px);border-radius:2px;bottom:0;content:"";display:block;height:6px;right:calc(var(--cnt-h-p) + (var(--bld-us) + 4px - 6px)/2 - 2px);margin:auto;opacity:.5;position:absolute;top:0;transform:rotate(90deg);transition:transform .2s ease-in-out;width:6px}.tp-rotv.tp-rotv-expanded .tp-rotv_m,.tp-fldv.tp-fldv-expanded>.tp-fldv_b>.tp-fldv_m{transform:none}.tp-rotv_c,.tp-fldv_c{box-sizing:border-box;height:0;opacity:0;overflow:hidden;padding-bottom:0;padding-top:0;position:relative;transition:height .2s ease-in-out,opacity .2s linear,padding .2s ease-in-out}.tp-rotv.tp-rotv-cpl:not(.tp-rotv-expanded) .tp-rotv_c,.tp-fldv.tp-fldv-cpl:not(.tp-fldv-expanded)>.tp-fldv_c{display:none}.tp-rotv.tp-rotv-expanded .tp-rotv_c,.tp-fldv.tp-fldv-expanded>.tp-fldv_c{opacity:1;padding-bottom:var(--cnt-v-p);padding-top:var(--cnt-v-p);transform:none;overflow:visible;transition:height .2s ease-in-out,opacity .2s linear .2s,padding .2s ease-in-out}.tp-lstv,.tp-coltxtv_m{position:relative}.tp-lstv_s{padding:0 20px 0 4px;width:100%}.tp-lstv_m,.tp-coltxtv_mm{bottom:0;margin:auto;pointer-events:none;position:absolute;right:2px;top:0}.tp-lstv_m svg,.tp-coltxtv_mm svg{bottom:0;height:16px;margin:auto;position:absolute;right:0;top:0;width:16px}.tp-lstv_m svg path,.tp-coltxtv_mm svg path{fill:currentColor}.tp-pndtxtv,.tp-coltxtv_w{display:flex}.tp-pndtxtv_a,.tp-coltxtv_c{width:100%}.tp-pndtxtv_a+.tp-pndtxtv_a,.tp-coltxtv_c+.tp-pndtxtv_a,.tp-pndtxtv_a+.tp-coltxtv_c,.tp-coltxtv_c+.tp-coltxtv_c{margin-left:2px}.tp-btnv_b{width:100%}.tp-btnv_t{text-align:center}.tp-ckbv_l{display:block;position:relative}.tp-ckbv_i{left:0;opacity:0;position:absolute;top:0}.tp-ckbv_w{background-color:var(--in-bg);border-radius:var(--elm-br);cursor:pointer;display:block;height:var(--bld-us);position:relative;width:var(--bld-us)}.tp-ckbv_w svg{bottom:0;display:block;height:16px;left:0;margin:auto;opacity:0;position:absolute;right:0;top:0;width:16px}.tp-ckbv_w svg path{fill:none;stroke:var(--in-fg);stroke-width:2}.tp-ckbv_i:hover+.tp-ckbv_w{background-color:var(--in-bg-h)}.tp-ckbv_i:focus+.tp-ckbv_w{background-color:var(--in-bg-f)}.tp-ckbv_i:active+.tp-ckbv_w{background-color:var(--in-bg-a)}.tp-ckbv_i:checked+.tp-ckbv_w svg{opacity:1}.tp-ckbv.tp-v-disabled .tp-ckbv_w{opacity:.5}.tp-colv{position:relative}.tp-colv_h{display:flex}.tp-colv_s{flex-grow:0;flex-shrink:0;width:var(--bld-us)}.tp-colv_t{flex:1;margin-left:4px}.tp-colv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-colv.tp-colv-expanded.tp-colv-cpl .tp-colv_p{overflow:visible}.tp-colv.tp-colv-expanded .tp-colv_p{margin-top:var(--bld-s);opacity:1}.tp-colv .tp-popv{left:calc(-1*var(--cnt-h-p));right:calc(-1*var(--cnt-h-p));top:var(--bld-us)}.tp-colpv_h,.tp-colpv_ap{margin-left:6px;margin-right:6px}.tp-colpv_h{margin-top:var(--bld-s)}.tp-colpv_rgb{display:flex;margin-top:var(--bld-s);width:100%}.tp-colpv_a{display:flex;margin-top:var(--cnt-v-p);padding-top:calc(var(--cnt-v-p) + 2px);position:relative}.tp-colpv_a::before{background-color:var(--grv-fg);content:"";height:2px;left:calc(-1*var(--cnt-h-p));position:absolute;right:calc(-1*var(--cnt-h-p));top:0}.tp-colpv.tp-v-disabled .tp-colpv_a::before{opacity:.5}.tp-colpv_ap{align-items:center;display:flex;flex:3}.tp-colpv_at{flex:1;margin-left:4px}.tp-svpv{border-radius:var(--elm-br);outline:none;overflow:hidden;position:relative}.tp-svpv.tp-v-disabled{opacity:.5}.tp-svpv_c{cursor:crosshair;display:block;height:calc(var(--bld-us)*4);width:100%}.tp-svpv_m{border-radius:100%;border:rgba(255,255,255,.75) solid 2px;box-sizing:border-box;filter:drop-shadow(0 0 1px rgba(0, 0, 0, 0.3));height:12px;margin-left:-6px;margin-top:-6px;pointer-events:none;position:absolute;width:12px}.tp-svpv:focus .tp-svpv_m{border-color:#fff}.tp-hplv{cursor:pointer;height:var(--bld-us);outline:none;position:relative}.tp-hplv.tp-v-disabled{opacity:.5}.tp-hplv_c{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAAABCAYAAABubagXAAAAQ0lEQVQoU2P8z8Dwn0GCgQEDi2OK/RBgYHjBgIpfovFh8j8YBIgzFGQxuqEgPhaDOT5gOhPkdCxOZeBg+IDFZZiGAgCaSSMYtcRHLgAAAABJRU5ErkJggg==);background-position:left top;background-repeat:no-repeat;background-size:100% 100%;border-radius:2px;display:block;height:4px;left:0;margin-top:-2px;position:absolute;top:50%;width:100%}.tp-hplv_m{border-radius:var(--elm-br);border:rgba(255,255,255,.75) solid 2px;box-shadow:0 0 2px rgba(0,0,0,.1);box-sizing:border-box;height:12px;left:50%;margin-left:-6px;margin-top:-6px;pointer-events:none;position:absolute;top:50%;width:12px}.tp-hplv:focus .tp-hplv_m{border-color:#fff}.tp-aplv{cursor:pointer;height:var(--bld-us);outline:none;position:relative;width:100%}.tp-aplv.tp-v-disabled{opacity:.5}.tp-aplv_b{background-color:#fff;background-image:linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%),linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%);background-size:4px 4px;background-position:0 0,2px 2px;border-radius:2px;display:block;height:4px;left:0;margin-top:-2px;overflow:hidden;position:absolute;top:50%;width:100%}.tp-aplv_c{bottom:0;left:0;position:absolute;right:0;top:0}.tp-aplv_m{background-color:#fff;background-image:linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%),linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%);background-size:12px 12px;background-position:0 0,6px 6px;border-radius:var(--elm-br);box-shadow:0 0 2px rgba(0,0,0,.1);height:12px;left:50%;margin-left:-6px;margin-top:-6px;overflow:hidden;pointer-events:none;position:absolute;top:50%;width:12px}.tp-aplv_p{border-radius:var(--elm-br);border:rgba(255,255,255,.75) solid 2px;box-sizing:border-box;bottom:0;left:0;position:absolute;right:0;top:0}.tp-aplv:focus .tp-aplv_p{border-color:#fff}.tp-colswv{background-color:#fff;background-image:linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%),linear-gradient(to top right, #ddd 25%, transparent 25%, transparent 75%, #ddd 75%);background-size:10px 10px;background-position:0 0,5px 5px;border-radius:var(--elm-br);overflow:hidden}.tp-colswv.tp-v-disabled{opacity:.5}.tp-colswv_sw{border-radius:0}.tp-colswv_b{-webkit-appearance:none;-moz-appearance:none;appearance:none;background-color:rgba(0,0,0,0);border-width:0;cursor:pointer;display:block;height:var(--bld-us);left:0;margin:0;outline:none;padding:0;position:absolute;top:0;width:var(--bld-us)}.tp-colswv_b:focus::after{border:rgba(255,255,255,.75) solid 2px;border-radius:var(--elm-br);bottom:0;content:"";display:block;left:0;position:absolute;right:0;top:0}.tp-coltxtv{display:flex;width:100%}.tp-coltxtv_m{margin-right:4px}.tp-coltxtv_ms{border-radius:var(--elm-br);color:var(--lbl-fg);cursor:pointer;height:var(--bld-us);line-height:var(--bld-us);padding:0 18px 0 4px}.tp-coltxtv_ms:hover{background-color:var(--in-bg-h)}.tp-coltxtv_ms:focus{background-color:var(--in-bg-f)}.tp-coltxtv_ms:active{background-color:var(--in-bg-a)}.tp-coltxtv_mm{color:var(--lbl-fg)}.tp-coltxtv.tp-v-disabled .tp-coltxtv_mm{opacity:.5}.tp-coltxtv_w{flex:1}.tp-dfwv{position:absolute;top:8px;right:8px;width:256px}.tp-fldv{position:relative}.tp-fldv.tp-fldv-not .tp-fldv_b{display:none}.tp-fldv_t{padding-left:4px}.tp-fldv_b:disabled .tp-fldv_m{display:none}.tp-fldv_c{padding-left:4px}.tp-fldv_i{bottom:0;color:var(--cnt-bg);left:0;overflow:hidden;position:absolute;top:calc(var(--bld-us) + 4px);width:var(--bs-br)}.tp-fldv_i::before{background-color:currentColor;bottom:0;content:"";left:0;position:absolute;top:0;width:4px}.tp-fldv_b:hover+.tp-fldv_i{color:var(--cnt-bg-h)}.tp-fldv_b:focus+.tp-fldv_i{color:var(--cnt-bg-f)}.tp-fldv_b:active+.tp-fldv_i{color:var(--cnt-bg-a)}.tp-fldv.tp-v-disabled>.tp-fldv_i{opacity:.5}.tp-grlv{position:relative}.tp-grlv_g{display:block;height:calc(var(--bld-us)*3)}.tp-grlv_g polyline{fill:none;stroke:var(--mo-fg);stroke-linejoin:round}.tp-grlv_t{margin-top:-4px;transition:left .05s,top .05s;visibility:hidden}.tp-grlv_t.tp-grlv_t-a{visibility:visible}.tp-grlv_t.tp-grlv_t-in{transition:none}.tp-grlv.tp-v-disabled .tp-grlv_g{opacity:.5}.tp-grlv .tp-ttv{background-color:var(--mo-fg)}.tp-grlv .tp-ttv::before{border-top-color:var(--mo-fg)}.tp-lblv{align-items:center;display:flex;line-height:1.3;padding-left:var(--cnt-h-p);padding-right:var(--cnt-h-p)}.tp-lblv.tp-lblv-nol{display:block}.tp-lblv_l{color:var(--lbl-fg);flex:1;-webkit-hyphens:auto;hyphens:auto;overflow:hidden;padding-left:4px;padding-right:16px}.tp-lblv.tp-v-disabled .tp-lblv_l{opacity:.5}.tp-lblv.tp-lblv-nol .tp-lblv_l{display:none}.tp-lblv_v{align-self:flex-start;flex-grow:0;flex-shrink:0;width:160px}.tp-lblv.tp-lblv-nol .tp-lblv_v{width:100%}.tp-lstv_s{padding:0 20px 0 4px;width:100%}.tp-lstv_m{color:var(--btn-fg)}.tp-sglv_i{padding:0 4px}.tp-sglv.tp-v-disabled .tp-sglv_i{opacity:.5}.tp-mllv_i{display:block;height:calc(var(--bld-us)*3);line-height:var(--bld-us);padding:0 4px;resize:none;white-space:pre}.tp-mllv.tp-v-disabled .tp-mllv_i{opacity:.5}.tp-p2dv{position:relative}.tp-p2dv_h{display:flex}.tp-p2dv_b{height:var(--bld-us);margin-right:4px;position:relative;width:var(--bld-us)}.tp-p2dv_b svg{display:block;height:16px;left:50%;margin-left:-8px;margin-top:-8px;position:absolute;top:50%;width:16px}.tp-p2dv_b svg path{stroke:currentColor;stroke-width:2}.tp-p2dv_b svg circle{fill:currentColor}.tp-p2dv_t{flex:1}.tp-p2dv_p{height:0;margin-top:0;opacity:0;overflow:hidden;transition:height .2s ease-in-out,opacity .2s linear,margin .2s ease-in-out}.tp-p2dv.tp-p2dv-expanded .tp-p2dv_p{margin-top:var(--bld-s);opacity:1}.tp-p2dv .tp-popv{left:calc(-1*var(--cnt-h-p));right:calc(-1*var(--cnt-h-p));top:var(--bld-us)}.tp-p2dpv{padding-left:calc(var(--bld-us) + 4px)}.tp-p2dpv_p{cursor:crosshair;height:0;overflow:hidden;padding-bottom:100%;position:relative}.tp-p2dpv.tp-v-disabled .tp-p2dpv_p{opacity:.5}.tp-p2dpv_g{display:block;height:100%;left:0;pointer-events:none;position:absolute;top:0;width:100%}.tp-p2dpv_ax{opacity:.1;stroke:var(--in-fg);stroke-dasharray:1}.tp-p2dpv_l{opacity:.5;stroke:var(--in-fg);stroke-dasharray:1}.tp-p2dpv_m{border:var(--in-fg) solid 1px;border-radius:50%;box-sizing:border-box;height:4px;margin-left:-2px;margin-top:-2px;position:absolute;width:4px}.tp-p2dpv_p:focus .tp-p2dpv_m{background-color:var(--in-fg);border-width:0}.tp-popv{background-color:var(--bs-bg);border-radius:6px;box-shadow:0 2px 4px var(--bs-sh);display:none;max-width:168px;padding:var(--cnt-v-p) var(--cnt-h-p);position:absolute;visibility:hidden;z-index:1000}.tp-popv.tp-popv-v{display:block;visibility:visible}.tp-sprv_r{background-color:var(--grv-fg);border-width:0;display:block;height:2px;margin:0;width:100%}.tp-sprv.tp-v-disabled .tp-sprv_r{opacity:.5}.tp-sldv.tp-v-disabled{opacity:.5}.tp-sldv_t{box-sizing:border-box;cursor:pointer;height:var(--bld-us);margin:0 6px;outline:none;position:relative}.tp-sldv_t::before{background-color:var(--in-bg);border-radius:1px;bottom:0;content:"";display:block;height:2px;left:0;margin:auto;position:absolute;right:0;top:0}.tp-sldv_k{height:100%;left:0;position:absolute;top:0}.tp-sldv_k::before{background-color:var(--in-fg);border-radius:1px;bottom:0;content:"";display:block;height:2px;left:0;margin-bottom:auto;margin-top:auto;position:absolute;right:0;top:0}.tp-sldv_k::after{background-color:var(--btn-bg);border-radius:var(--elm-br);bottom:0;content:"";display:block;height:12px;margin-bottom:auto;margin-top:auto;position:absolute;right:-6px;top:0;width:12px}.tp-sldv_t:hover .tp-sldv_k::after{background-color:var(--btn-bg-h)}.tp-sldv_t:focus .tp-sldv_k::after{background-color:var(--btn-bg-f)}.tp-sldv_t:active .tp-sldv_k::after{background-color:var(--btn-bg-a)}.tp-sldtxtv{display:flex}.tp-sldtxtv_s{flex:2}.tp-sldtxtv_t{flex:1;margin-left:4px}.tp-tabv{position:relative}.tp-tabv_t{align-items:flex-end;color:var(--cnt-bg);display:flex;overflow:hidden;position:relative}.tp-tabv_t:hover{color:var(--cnt-bg-h)}.tp-tabv_t:has(*:focus){color:var(--cnt-bg-f)}.tp-tabv_t:has(*:active){color:var(--cnt-bg-a)}.tp-tabv_t::before{background-color:currentColor;bottom:0;content:"";height:2px;left:0;pointer-events:none;position:absolute;right:0}.tp-tabv.tp-v-disabled .tp-tabv_t::before{opacity:.5}.tp-tabv.tp-tabv-nop .tp-tabv_t{height:calc(var(--bld-us) + 4px);position:relative}.tp-tabv.tp-tabv-nop .tp-tabv_t::before{background-color:var(--cnt-bg);bottom:0;content:"";height:2px;left:0;position:absolute;right:0}.tp-tabv_c{padding-bottom:var(--cnt-v-p);padding-left:4px;padding-top:var(--cnt-v-p)}.tp-tabv_i{bottom:0;color:var(--cnt-bg);left:0;overflow:hidden;position:absolute;top:calc(var(--bld-us) + 4px);width:var(--bs-br)}.tp-tabv_i::before{background-color:currentColor;bottom:0;content:"";left:0;position:absolute;top:0;width:4px}.tp-tabv_t:hover+.tp-tabv_i{color:var(--cnt-bg-h)}.tp-tabv_t:has(*:focus)+.tp-tabv_i{color:var(--cnt-bg-f)}.tp-tabv_t:has(*:active)+.tp-tabv_i{color:var(--cnt-bg-a)}.tp-tabv.tp-v-disabled>.tp-tabv_i{opacity:.5}.tp-tbiv{flex:1;min-width:0;position:relative}.tp-tbiv+.tp-tbiv{margin-left:2px}.tp-tbiv+.tp-tbiv.tp-v-disabled::before{opacity:.5}.tp-tbiv_b{display:block;padding-left:calc(var(--cnt-h-p) + 4px);padding-right:calc(var(--cnt-h-p) + 4px);position:relative;width:100%}.tp-tbiv_b:disabled{opacity:.5}.tp-tbiv_b::before{background-color:var(--cnt-bg);bottom:2px;content:"";left:0;pointer-events:none;position:absolute;right:0;top:0}.tp-tbiv_b:hover::before{background-color:var(--cnt-bg-h)}.tp-tbiv_b:focus::before{background-color:var(--cnt-bg-f)}.tp-tbiv_b:active::before{background-color:var(--cnt-bg-a)}.tp-tbiv_t{color:var(--cnt-fg);height:calc(var(--bld-us) + 4px);line-height:calc(var(--bld-us) + 4px);opacity:.5;overflow:hidden;text-overflow:ellipsis}.tp-tbiv.tp-tbiv-sel .tp-tbiv_t{opacity:1}.tp-txtv{position:relative}.tp-txtv_i{padding:0 4px}.tp-txtv.tp-txtv-fst .tp-txtv_i{border-bottom-right-radius:0;border-top-right-radius:0}.tp-txtv.tp-txtv-mid .tp-txtv_i{border-radius:0}.tp-txtv.tp-txtv-lst .tp-txtv_i{border-bottom-left-radius:0;border-top-left-radius:0}.tp-txtv.tp-txtv-num .tp-txtv_i{text-align:right}.tp-txtv.tp-txtv-drg .tp-txtv_i{opacity:.3}.tp-txtv_k{cursor:pointer;height:100%;left:-3px;position:absolute;top:0;width:12px}.tp-txtv_k::before{background-color:var(--in-fg);border-radius:1px;bottom:0;content:"";height:calc(var(--bld-us) - 4px);left:50%;margin-bottom:auto;margin-left:-1px;margin-top:auto;opacity:.1;position:absolute;top:0;transition:border-radius .1s,height .1s,transform .1s,width .1s;width:2px}.tp-txtv_k:hover::before,.tp-txtv.tp-txtv-drg .tp-txtv_k::before{opacity:1}.tp-txtv.tp-txtv-drg .tp-txtv_k::before{border-radius:50%;height:4px;transform:translateX(-1px);width:4px}.tp-txtv_g{bottom:0;display:block;height:8px;left:50%;margin:auto;overflow:visible;pointer-events:none;position:absolute;top:0;visibility:hidden;width:100%}.tp-txtv.tp-txtv-drg .tp-txtv_g{visibility:visible}.tp-txtv_gb{fill:none;stroke:var(--in-fg);stroke-dasharray:1}.tp-txtv_gh{fill:none;stroke:var(--in-fg)}.tp-txtv .tp-ttv{margin-left:6px;visibility:hidden}.tp-txtv.tp-txtv-drg .tp-ttv{visibility:visible}.tp-ttv{background-color:var(--in-fg);border-radius:var(--elm-br);color:var(--bs-bg);padding:2px 4px;pointer-events:none;position:absolute;transform:translate(-50%, -100%)}.tp-ttv::before{border-color:var(--in-fg) rgba(0,0,0,0) rgba(0,0,0,0) rgba(0,0,0,0);border-style:solid;border-width:2px;box-sizing:border-box;content:"";font-size:.9em;height:4px;left:50%;margin-left:-2px;position:absolute;top:100%;width:4px}.tp-rotv{background-color:var(--bs-bg);border-radius:var(--bs-br);box-shadow:0 2px 4px var(--bs-sh);font-family:var(--font-family);font-size:11px;font-weight:500;line-height:1;text-align:left}.tp-rotv_b{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br);border-top-left-radius:var(--bs-br);border-top-right-radius:var(--bs-br);padding-left:calc(4px + var(--bld-us) + var(--cnt-h-p));text-align:center}.tp-rotv.tp-rotv-expanded .tp-rotv_b{border-bottom-left-radius:0;border-bottom-right-radius:0}.tp-rotv.tp-rotv-not .tp-rotv_b{display:none}.tp-rotv_b:disabled .tp-rotv_m{display:none}.tp-rotv_c>.tp-fldv.tp-v-lst>.tp-fldv_c{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br)}.tp-rotv_c>.tp-fldv.tp-v-lst>.tp-fldv_i{border-bottom-left-radius:var(--bs-br)}.tp-rotv_c>.tp-fldv.tp-v-lst:not(.tp-fldv-expanded)>.tp-fldv_b{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br)}.tp-rotv_c .tp-fldv.tp-v-vlst:not(.tp-fldv-expanded)>.tp-fldv_b{border-bottom-right-radius:var(--bs-br)}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-fldv.tp-v-fst{margin-top:calc(-1*var(--cnt-v-p))}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-fldv.tp-v-fst>.tp-fldv_b{border-top-left-radius:var(--bs-br);border-top-right-radius:var(--bs-br)}.tp-rotv_c>.tp-tabv.tp-v-lst>.tp-tabv_c{border-bottom-left-radius:var(--bs-br);border-bottom-right-radius:var(--bs-br)}.tp-rotv_c>.tp-tabv.tp-v-lst>.tp-tabv_i{border-bottom-left-radius:var(--bs-br)}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-tabv.tp-v-fst{margin-top:calc(-1*var(--cnt-v-p))}.tp-rotv.tp-rotv-not .tp-rotv_c>.tp-tabv.tp-v-fst>.tp-tabv_t{border-top-left-radius:var(--bs-br);border-top-right-radius:var(--bs-br)}.tp-rotv.tp-v-disabled,.tp-rotv .tp-v-disabled{pointer-events:none}.tp-rotv.tp-v-hidden,.tp-rotv .tp-v-hidden{display:none}');
            this.pool_.getAll().forEach((plugin)=>{
                this.embedPluginStyle_(plugin);
            });
            this.registerPlugin({
                plugins: [
                    SliderBladePlugin,
                    ListBladePlugin,
                    TabBladePlugin,
                    TextBladePlugin
                ]
            });
        }
    }
    const VERSION = new Semver('3.1.10');
    exports1.BladeApi = BladeApi;
    exports1.ButtonApi = ButtonApi;
    exports1.FolderApi = FolderApi;
    exports1.InputBindingApi = InputBindingApi;
    exports1.ListApi = ListApi;
    exports1.MonitorBindingApi = MonitorBindingApi;
    exports1.Pane = Pane;
    exports1.SeparatorApi = SeparatorApi;
    exports1.SliderApi = SliderApi;
    exports1.TabApi = TabApi;
    exports1.TabPageApi = TabPageApi;
    exports1.TextApi = TextApi;
    exports1.TpChangeEvent = TpChangeEvent;
    exports1.VERSION = VERSION;
    Object.defineProperty(exports1, '__esModule', {
        value: true
    });
});



var $9jC0R = parcelRequire("9jC0R");
/* REMINDER
 * To size a mesh to its texture:
 * mesh.scale.x = material.map.source.data.naturalWidth
 * mesh.scale.y = material.map.source.data.naturalHeight
 */ 


const $e4bd4b396d3c4aec$var$_box = new (0, $d5b85d29c0b78636$export$6f7d5a9418ab2aa3)();
const $e4bd4b396d3c4aec$var$_vector = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
class $e4bd4b396d3c4aec$export$5b1256aa5274bf8 extends (0, $d5b85d29c0b78636$export$231f009cbe414146) {
    constructor(){
        super();
        this.isLineSegmentsGeometry = true;
        this.type = 'LineSegmentsGeometry';
        const positions = [
            -1,
            2,
            0,
            1,
            2,
            0,
            -1,
            1,
            0,
            1,
            1,
            0,
            -1,
            0,
            0,
            1,
            0,
            0,
            -1,
            -1,
            0,
            1,
            -1,
            0
        ];
        const uvs = [
            -1,
            2,
            1,
            2,
            -1,
            1,
            1,
            1,
            -1,
            -1,
            1,
            -1,
            -1,
            -2,
            1,
            -2
        ];
        const index = [
            0,
            2,
            1,
            2,
            3,
            1,
            2,
            4,
            3,
            4,
            5,
            3,
            4,
            6,
            5,
            6,
            7,
            5
        ];
        this.setIndex(index);
        this.setAttribute('position', new (0, $d5b85d29c0b78636$export$cbe7a62641830ebd)(positions, 3));
        this.setAttribute('uv', new (0, $d5b85d29c0b78636$export$cbe7a62641830ebd)(uvs, 2));
    }
    applyMatrix4(matrix) {
        const start = this.attributes.instanceStart;
        const end = this.attributes.instanceEnd;
        if (start !== undefined) {
            start.applyMatrix4(matrix);
            end.applyMatrix4(matrix);
            start.needsUpdate = true;
        }
        if (this.boundingBox !== null) this.computeBoundingBox();
        if (this.boundingSphere !== null) this.computeBoundingSphere();
        return this;
    }
    setPositions(array) {
        let lineSegments;
        if (array instanceof Float32Array) lineSegments = array;
        else if (Array.isArray(array)) lineSegments = new Float32Array(array);
        const instanceBuffer = new (0, $d5b85d29c0b78636$export$25ec0e1af1389358)(lineSegments, 6, 1); // xyz, xyz
        this.setAttribute('instanceStart', new (0, $d5b85d29c0b78636$export$920b6d07334599c7)(instanceBuffer, 3, 0)); // xyz
        this.setAttribute('instanceEnd', new (0, $d5b85d29c0b78636$export$920b6d07334599c7)(instanceBuffer, 3, 3)); // xyz
        this.instanceCount = this.attributes.instanceStart.count;
        //
        this.computeBoundingBox();
        this.computeBoundingSphere();
        return this;
    }
    setColors(array) {
        let colors;
        if (array instanceof Float32Array) colors = array;
        else if (Array.isArray(array)) colors = new Float32Array(array);
        const instanceColorBuffer = new (0, $d5b85d29c0b78636$export$25ec0e1af1389358)(colors, 6, 1); // rgb, rgb
        this.setAttribute('instanceColorStart', new (0, $d5b85d29c0b78636$export$920b6d07334599c7)(instanceColorBuffer, 3, 0)); // rgb
        this.setAttribute('instanceColorEnd', new (0, $d5b85d29c0b78636$export$920b6d07334599c7)(instanceColorBuffer, 3, 3)); // rgb
        return this;
    }
    fromWireframeGeometry(geometry) {
        this.setPositions(geometry.attributes.position.array);
        return this;
    }
    fromEdgesGeometry(geometry) {
        this.setPositions(geometry.attributes.position.array);
        return this;
    }
    fromMesh(mesh) {
        this.fromWireframeGeometry(new (0, $d5b85d29c0b78636$export$4b739da06d24892b)(mesh.geometry));
        // set colors, maybe
        return this;
    }
    fromLineSegments(lineSegments) {
        const geometry = lineSegments.geometry;
        this.setPositions(geometry.attributes.position.array); // assumes non-indexed
        // set colors, maybe
        return this;
    }
    computeBoundingBox() {
        if (this.boundingBox === null) this.boundingBox = new (0, $d5b85d29c0b78636$export$6f7d5a9418ab2aa3)();
        const start = this.attributes.instanceStart;
        const end = this.attributes.instanceEnd;
        if (start !== undefined && end !== undefined) {
            this.boundingBox.setFromBufferAttribute(start);
            $e4bd4b396d3c4aec$var$_box.setFromBufferAttribute(end);
            this.boundingBox.union($e4bd4b396d3c4aec$var$_box);
        }
    }
    computeBoundingSphere() {
        if (this.boundingSphere === null) this.boundingSphere = new (0, $d5b85d29c0b78636$export$805e8b72413ccaba)();
        if (this.boundingBox === null) this.computeBoundingBox();
        const start = this.attributes.instanceStart;
        const end = this.attributes.instanceEnd;
        if (start !== undefined && end !== undefined) {
            const center = this.boundingSphere.center;
            this.boundingBox.getCenter(center);
            let maxRadiusSq = 0;
            for(let i = 0, il = start.count; i < il; i++){
                $e4bd4b396d3c4aec$var$_vector.fromBufferAttribute(start, i);
                maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared($e4bd4b396d3c4aec$var$_vector));
                $e4bd4b396d3c4aec$var$_vector.fromBufferAttribute(end, i);
                maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared($e4bd4b396d3c4aec$var$_vector));
            }
            this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
            if (isNaN(this.boundingSphere.radius)) console.error('THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', this);
        }
    }
    toJSON() {
    // todo
    }
    applyMatrix(matrix) {
        console.warn('THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().');
        return this.applyMatrix4(matrix);
    }
}



(0, $3dd44ec8564e7230$export$6643083551874bf5).line = {
    worldUnits: {
        value: 1
    },
    linewidth: {
        value: 1
    },
    resolution: {
        value: new (0, $d5b85d29c0b78636$export$c977b3e384af9ae1)(1, 1)
    },
    dashOffset: {
        value: 0
    },
    dashScale: {
        value: 1
    },
    dashSize: {
        value: 1
    },
    gapSize: {
        value: 1
    } // todo FIX - maybe change to totalSize
};
(0, $3dd44ec8564e7230$export$bee4a7d47f8f5014)['line'] = {
    uniforms: (0, $d5b85d29c0b78636$export$d8ecdf8615bfea69).merge([
        (0, $3dd44ec8564e7230$export$6643083551874bf5).common,
        (0, $3dd44ec8564e7230$export$6643083551874bf5).fog,
        (0, $3dd44ec8564e7230$export$6643083551874bf5).line
    ]),
    vertexShader: /* glsl */ `
		#include <common>
		#include <color_pars_vertex>
		#include <fog_pars_vertex>
		#include <logdepthbuf_pars_vertex>
		#include <clipping_planes_pars_vertex>

		uniform float linewidth;
		uniform vec2 resolution;

		attribute vec3 instanceStart;
		attribute vec3 instanceEnd;

		attribute vec3 instanceColorStart;
		attribute vec3 instanceColorEnd;

		#ifdef WORLD_UNITS

			varying vec4 worldPos;
			varying vec3 worldStart;
			varying vec3 worldEnd;

			#ifdef USE_DASH

				varying vec2 vUv;

			#endif

		#else

			varying vec2 vUv;

		#endif

		#ifdef USE_DASH

			uniform float dashScale;
			attribute float instanceDistanceStart;
			attribute float instanceDistanceEnd;
			varying float vLineDistance;

		#endif

		void trimSegment( const in vec4 start, inout vec4 end ) {

			// trim end segment so it terminates between the camera plane and the near plane

			// conservative estimate of the near plane
			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
			float nearEstimate = - 0.5 * b / a;

			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );

			end.xyz = mix( start.xyz, end.xyz, alpha );

		}

		void main() {

			#ifdef USE_COLOR

				vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd;

			#endif

			#ifdef USE_DASH

				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
				vUv = uv;

			#endif

			float aspect = resolution.x / resolution.y;

			// camera space
			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );

			#ifdef WORLD_UNITS

				worldStart = start.xyz;
				worldEnd = end.xyz;

			#else

				vUv = uv;

			#endif

			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
			// but we need to perform ndc-space calculations in the shader, so we must address this issue directly
			// perhaps there is a more elegant solution -- WestLangley

			bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column

			if ( perspective ) {

				if ( start.z < 0.0 && end.z >= 0.0 ) {

					trimSegment( start, end );

				} else if ( end.z < 0.0 && start.z >= 0.0 ) {

					trimSegment( end, start );

				}

			}

			// clip space
			vec4 clipStart = projectionMatrix * start;
			vec4 clipEnd = projectionMatrix * end;

			// ndc space
			vec3 ndcStart = clipStart.xyz / clipStart.w;
			vec3 ndcEnd = clipEnd.xyz / clipEnd.w;

			// direction
			vec2 dir = ndcEnd.xy - ndcStart.xy;

			// account for clip-space aspect ratio
			dir.x *= aspect;
			dir = normalize( dir );

			#ifdef WORLD_UNITS

				vec3 worldDir = normalize( end.xyz - start.xyz );
				vec3 tmpFwd = normalize( mix( start.xyz, end.xyz, 0.5 ) );
				vec3 worldUp = normalize( cross( worldDir, tmpFwd ) );
				vec3 worldFwd = cross( worldDir, worldUp );
				worldPos = position.y < 0.5 ? start: end;

				// height offset
				float hw = linewidth * 0.5;
				worldPos.xyz += position.x < 0.0 ? hw * worldUp : - hw * worldUp;

				// don't extend the line if we're rendering dashes because we
				// won't be rendering the endcaps
				#ifndef USE_DASH

					// cap extension
					worldPos.xyz += position.y < 0.5 ? - hw * worldDir : hw * worldDir;

					// add width to the box
					worldPos.xyz += worldFwd * hw;

					// endcaps
					if ( position.y > 1.0 || position.y < 0.0 ) {

						worldPos.xyz -= worldFwd * 2.0 * hw;

					}

				#endif

				// project the worldpos
				vec4 clip = projectionMatrix * worldPos;

				// shift the depth of the projected points so the line
				// segments overlap neatly
				vec3 clipPose = ( position.y < 0.5 ) ? ndcStart : ndcEnd;
				clip.z = clipPose.z * clip.w;

			#else

				vec2 offset = vec2( dir.y, - dir.x );
				// undo aspect ratio adjustment
				dir.x /= aspect;
				offset.x /= aspect;

				// sign flip
				if ( position.x < 0.0 ) offset *= - 1.0;

				// endcaps
				if ( position.y < 0.0 ) {

					offset += - dir;

				} else if ( position.y > 1.0 ) {

					offset += dir;

				}

				// adjust for linewidth
				offset *= linewidth;

				// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
				offset /= resolution.y;

				// select end
				vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;

				// back to clip space
				offset *= clip.w;

				clip.xy += offset;

			#endif

			gl_Position = clip;

			vec4 mvPosition = ( position.y < 0.5 ) ? start : end; // this is an approximation

			#include <logdepthbuf_vertex>
			#include <clipping_planes_vertex>
			#include <fog_vertex>

		}
		`,
    fragmentShader: /* glsl */ `
		uniform vec3 diffuse;
		uniform float opacity;
		uniform float linewidth;

		#ifdef USE_DASH

			uniform float dashOffset;
			uniform float dashSize;
			uniform float gapSize;

		#endif

		varying float vLineDistance;

		#ifdef WORLD_UNITS

			varying vec4 worldPos;
			varying vec3 worldStart;
			varying vec3 worldEnd;

			#ifdef USE_DASH

				varying vec2 vUv;

			#endif

		#else

			varying vec2 vUv;

		#endif

		#include <common>
		#include <color_pars_fragment>
		#include <fog_pars_fragment>
		#include <logdepthbuf_pars_fragment>
		#include <clipping_planes_pars_fragment>

		vec2 closestLineToLine(vec3 p1, vec3 p2, vec3 p3, vec3 p4) {

			float mua;
			float mub;

			vec3 p13 = p1 - p3;
			vec3 p43 = p4 - p3;

			vec3 p21 = p2 - p1;

			float d1343 = dot( p13, p43 );
			float d4321 = dot( p43, p21 );
			float d1321 = dot( p13, p21 );
			float d4343 = dot( p43, p43 );
			float d2121 = dot( p21, p21 );

			float denom = d2121 * d4343 - d4321 * d4321;

			float numer = d1343 * d4321 - d1321 * d4343;

			mua = numer / denom;
			mua = clamp( mua, 0.0, 1.0 );
			mub = ( d1343 + d4321 * ( mua ) ) / d4343;
			mub = clamp( mub, 0.0, 1.0 );

			return vec2( mua, mub );

		}

		void main() {

			#include <clipping_planes_fragment>

			#ifdef USE_DASH

				if ( vUv.y < - 1.0 || vUv.y > 1.0 ) discard; // discard endcaps

				if ( mod( vLineDistance + dashOffset, dashSize + gapSize ) > dashSize ) discard; // todo - FIX

			#endif

			float alpha = opacity;

			#ifdef WORLD_UNITS

				// Find the closest points on the view ray and the line segment
				vec3 rayEnd = normalize( worldPos.xyz ) * 1e5;
				vec3 lineDir = worldEnd - worldStart;
				vec2 params = closestLineToLine( worldStart, worldEnd, vec3( 0.0, 0.0, 0.0 ), rayEnd );

				vec3 p1 = worldStart + lineDir * params.x;
				vec3 p2 = rayEnd * params.y;
				vec3 delta = p1 - p2;
				float len = length( delta );
				float norm = len / linewidth;

				#ifndef USE_DASH

					#ifdef USE_ALPHA_TO_COVERAGE

						float dnorm = fwidth( norm );
						alpha = 1.0 - smoothstep( 0.5 - dnorm, 0.5 + dnorm, norm );

					#else

						if ( norm > 0.5 ) {

							discard;

						}

					#endif

				#endif

			#else

				#ifdef USE_ALPHA_TO_COVERAGE

					// artifacts appear on some hardware if a derivative is taken within a conditional
					float a = vUv.x;
					float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
					float len2 = a * a + b * b;
					float dlen = fwidth( len2 );

					if ( abs( vUv.y ) > 1.0 ) {

						alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 );

					}

				#else

					if ( abs( vUv.y ) > 1.0 ) {

						float a = vUv.x;
						float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
						float len2 = a * a + b * b;

						if ( len2 > 1.0 ) discard;

					}

				#endif

			#endif

			vec4 diffuseColor = vec4( diffuse, alpha );

			#include <logdepthbuf_fragment>
			#include <color_fragment>

			gl_FragColor = vec4( diffuseColor.rgb, alpha );

			#include <tonemapping_fragment>
			#include <colorspace_fragment>
			#include <fog_fragment>
			#include <premultiplied_alpha_fragment>

		}
		`
};
class $21dd365b363a2479$export$d19cd1378966f3d3 extends (0, $d5b85d29c0b78636$export$83c7d75d550a8b0d) {
    constructor(parameters){
        super({
            type: 'LineMaterial',
            uniforms: (0, $d5b85d29c0b78636$export$d8ecdf8615bfea69).clone((0, $3dd44ec8564e7230$export$bee4a7d47f8f5014)['line'].uniforms),
            vertexShader: (0, $3dd44ec8564e7230$export$bee4a7d47f8f5014)['line'].vertexShader,
            fragmentShader: (0, $3dd44ec8564e7230$export$bee4a7d47f8f5014)['line'].fragmentShader,
            clipping: true // required for clipping support
        });
        this.isLineMaterial = true;
        this.setValues(parameters);
    }
    get color() {
        return this.uniforms.diffuse.value;
    }
    set color(value) {
        this.uniforms.diffuse.value = value;
    }
    get worldUnits() {
        return 'WORLD_UNITS' in this.defines;
    }
    set worldUnits(value) {
        if (value === true) this.defines.WORLD_UNITS = '';
        else delete this.defines.WORLD_UNITS;
    }
    get linewidth() {
        return this.uniforms.linewidth.value;
    }
    set linewidth(value) {
        if (!this.uniforms.linewidth) return;
        this.uniforms.linewidth.value = value;
    }
    get dashed() {
        return 'USE_DASH' in this.defines;
    }
    set dashed(value) {
        if (value === true !== this.dashed) this.needsUpdate = true;
        if (value === true) this.defines.USE_DASH = '';
        else delete this.defines.USE_DASH;
    }
    get dashScale() {
        return this.uniforms.dashScale.value;
    }
    set dashScale(value) {
        this.uniforms.dashScale.value = value;
    }
    get dashSize() {
        return this.uniforms.dashSize.value;
    }
    set dashSize(value) {
        this.uniforms.dashSize.value = value;
    }
    get dashOffset() {
        return this.uniforms.dashOffset.value;
    }
    set dashOffset(value) {
        this.uniforms.dashOffset.value = value;
    }
    get gapSize() {
        return this.uniforms.gapSize.value;
    }
    set gapSize(value) {
        this.uniforms.gapSize.value = value;
    }
    get opacity() {
        return this.uniforms.opacity.value;
    }
    set opacity(value) {
        if (!this.uniforms) return;
        this.uniforms.opacity.value = value;
    }
    get resolution() {
        return this.uniforms.resolution.value;
    }
    set resolution(value) {
        this.uniforms.resolution.value.copy(value);
    }
    get alphaToCoverage() {
        return 'USE_ALPHA_TO_COVERAGE' in this.defines;
    }
    set alphaToCoverage(value) {
        if (!this.defines) return;
        if (value === true !== this.alphaToCoverage) this.needsUpdate = true;
        if (value === true) this.defines.USE_ALPHA_TO_COVERAGE = '';
        else delete this.defines.USE_ALPHA_TO_COVERAGE;
    }
}


const $5e5d1b10c766041f$var$_viewport = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
const $5e5d1b10c766041f$var$_start = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
const $5e5d1b10c766041f$var$_end = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
const $5e5d1b10c766041f$var$_start4 = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
const $5e5d1b10c766041f$var$_end4 = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
const $5e5d1b10c766041f$var$_ssOrigin = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
const $5e5d1b10c766041f$var$_ssOrigin3 = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
const $5e5d1b10c766041f$var$_mvMatrix = new (0, $d5b85d29c0b78636$export$2ae72fc923e5eb5)();
const $5e5d1b10c766041f$var$_line = new (0, $d5b85d29c0b78636$export$e0ba6359f1954fd3)();
const $5e5d1b10c766041f$var$_closestPoint = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
const $5e5d1b10c766041f$var$_box = new (0, $d5b85d29c0b78636$export$6f7d5a9418ab2aa3)();
const $5e5d1b10c766041f$var$_sphere = new (0, $d5b85d29c0b78636$export$805e8b72413ccaba)();
const $5e5d1b10c766041f$var$_clipToWorldVector = new (0, $d5b85d29c0b78636$export$fa7daccca11cdbe3)();
let $5e5d1b10c766041f$var$_ray, $5e5d1b10c766041f$var$_lineWidth;
// Returns the margin required to expand by in world space given the distance from the camera,
// line width, resolution, and camera projection
function $5e5d1b10c766041f$var$getWorldSpaceHalfWidth(camera, distance, resolution) {
    // transform into clip space, adjust the x and y values by the pixel width offset, then
    // transform back into world space to get world offset. Note clip space is [-1, 1] so full
    // width does not need to be halved.
    $5e5d1b10c766041f$var$_clipToWorldVector.set(0, 0, -distance, 1.0).applyMatrix4(camera.projectionMatrix);
    $5e5d1b10c766041f$var$_clipToWorldVector.multiplyScalar(1.0 / $5e5d1b10c766041f$var$_clipToWorldVector.w);
    $5e5d1b10c766041f$var$_clipToWorldVector.x = $5e5d1b10c766041f$var$_lineWidth / resolution.width;
    $5e5d1b10c766041f$var$_clipToWorldVector.y = $5e5d1b10c766041f$var$_lineWidth / resolution.height;
    $5e5d1b10c766041f$var$_clipToWorldVector.applyMatrix4(camera.projectionMatrixInverse);
    $5e5d1b10c766041f$var$_clipToWorldVector.multiplyScalar(1.0 / $5e5d1b10c766041f$var$_clipToWorldVector.w);
    return Math.abs(Math.max($5e5d1b10c766041f$var$_clipToWorldVector.x, $5e5d1b10c766041f$var$_clipToWorldVector.y));
}
function $5e5d1b10c766041f$var$raycastWorldUnits(lineSegments, intersects) {
    const matrixWorld = lineSegments.matrixWorld;
    const geometry = lineSegments.geometry;
    const instanceStart = geometry.attributes.instanceStart;
    const instanceEnd = geometry.attributes.instanceEnd;
    const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
    for(let i = 0, l = segmentCount; i < l; i++){
        $5e5d1b10c766041f$var$_line.start.fromBufferAttribute(instanceStart, i);
        $5e5d1b10c766041f$var$_line.end.fromBufferAttribute(instanceEnd, i);
        $5e5d1b10c766041f$var$_line.applyMatrix4(matrixWorld);
        const pointOnLine = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        const point = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
        $5e5d1b10c766041f$var$_ray.distanceSqToSegment($5e5d1b10c766041f$var$_line.start, $5e5d1b10c766041f$var$_line.end, point, pointOnLine);
        const isInside = point.distanceTo(pointOnLine) < $5e5d1b10c766041f$var$_lineWidth * 0.5;
        if (isInside) intersects.push({
            point: point,
            pointOnLine: pointOnLine,
            distance: $5e5d1b10c766041f$var$_ray.origin.distanceTo(point),
            object: lineSegments,
            face: null,
            faceIndex: i,
            uv: null,
            uv1: null
        });
    }
}
function $5e5d1b10c766041f$var$raycastScreenSpace(lineSegments, camera, intersects) {
    const projectionMatrix = camera.projectionMatrix;
    const material = lineSegments.material;
    const resolution = material.resolution;
    const matrixWorld = lineSegments.matrixWorld;
    const geometry = lineSegments.geometry;
    const instanceStart = geometry.attributes.instanceStart;
    const instanceEnd = geometry.attributes.instanceEnd;
    const segmentCount = Math.min(geometry.instanceCount, instanceStart.count);
    const near = -camera.near;
    //
    // pick a point 1 unit out along the ray to avoid the ray origin
    // sitting at the camera origin which will cause "w" to be 0 when
    // applying the projection matrix.
    $5e5d1b10c766041f$var$_ray.at(1, $5e5d1b10c766041f$var$_ssOrigin);
    // ndc space [ - 1.0, 1.0 ]
    $5e5d1b10c766041f$var$_ssOrigin.w = 1;
    $5e5d1b10c766041f$var$_ssOrigin.applyMatrix4(camera.matrixWorldInverse);
    $5e5d1b10c766041f$var$_ssOrigin.applyMatrix4(projectionMatrix);
    $5e5d1b10c766041f$var$_ssOrigin.multiplyScalar(1 / $5e5d1b10c766041f$var$_ssOrigin.w);
    // screen space
    $5e5d1b10c766041f$var$_ssOrigin.x *= resolution.x / 2;
    $5e5d1b10c766041f$var$_ssOrigin.y *= resolution.y / 2;
    $5e5d1b10c766041f$var$_ssOrigin.z = 0;
    $5e5d1b10c766041f$var$_ssOrigin3.copy($5e5d1b10c766041f$var$_ssOrigin);
    $5e5d1b10c766041f$var$_mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld);
    for(let i = 0, l = segmentCount; i < l; i++){
        $5e5d1b10c766041f$var$_start4.fromBufferAttribute(instanceStart, i);
        $5e5d1b10c766041f$var$_end4.fromBufferAttribute(instanceEnd, i);
        $5e5d1b10c766041f$var$_start4.w = 1;
        $5e5d1b10c766041f$var$_end4.w = 1;
        // camera space
        $5e5d1b10c766041f$var$_start4.applyMatrix4($5e5d1b10c766041f$var$_mvMatrix);
        $5e5d1b10c766041f$var$_end4.applyMatrix4($5e5d1b10c766041f$var$_mvMatrix);
        // skip the segment if it's entirely behind the camera
        const isBehindCameraNear = $5e5d1b10c766041f$var$_start4.z > near && $5e5d1b10c766041f$var$_end4.z > near;
        if (isBehindCameraNear) continue;
        // trim the segment if it extends behind camera near
        if ($5e5d1b10c766041f$var$_start4.z > near) {
            const deltaDist = $5e5d1b10c766041f$var$_start4.z - $5e5d1b10c766041f$var$_end4.z;
            const t = ($5e5d1b10c766041f$var$_start4.z - near) / deltaDist;
            $5e5d1b10c766041f$var$_start4.lerp($5e5d1b10c766041f$var$_end4, t);
        } else if ($5e5d1b10c766041f$var$_end4.z > near) {
            const deltaDist = $5e5d1b10c766041f$var$_end4.z - $5e5d1b10c766041f$var$_start4.z;
            const t = ($5e5d1b10c766041f$var$_end4.z - near) / deltaDist;
            $5e5d1b10c766041f$var$_end4.lerp($5e5d1b10c766041f$var$_start4, t);
        }
        // clip space
        $5e5d1b10c766041f$var$_start4.applyMatrix4(projectionMatrix);
        $5e5d1b10c766041f$var$_end4.applyMatrix4(projectionMatrix);
        // ndc space [ - 1.0, 1.0 ]
        $5e5d1b10c766041f$var$_start4.multiplyScalar(1 / $5e5d1b10c766041f$var$_start4.w);
        $5e5d1b10c766041f$var$_end4.multiplyScalar(1 / $5e5d1b10c766041f$var$_end4.w);
        // screen space
        $5e5d1b10c766041f$var$_start4.x *= resolution.x / 2;
        $5e5d1b10c766041f$var$_start4.y *= resolution.y / 2;
        $5e5d1b10c766041f$var$_end4.x *= resolution.x / 2;
        $5e5d1b10c766041f$var$_end4.y *= resolution.y / 2;
        // create 2d segment
        $5e5d1b10c766041f$var$_line.start.copy($5e5d1b10c766041f$var$_start4);
        $5e5d1b10c766041f$var$_line.start.z = 0;
        $5e5d1b10c766041f$var$_line.end.copy($5e5d1b10c766041f$var$_end4);
        $5e5d1b10c766041f$var$_line.end.z = 0;
        // get closest point on ray to segment
        const param = $5e5d1b10c766041f$var$_line.closestPointToPointParameter($5e5d1b10c766041f$var$_ssOrigin3, true);
        $5e5d1b10c766041f$var$_line.at(param, $5e5d1b10c766041f$var$_closestPoint);
        // check if the intersection point is within clip space
        const zPos = (0, $d5b85d29c0b78636$export$6a7ef315a0d1ef07).lerp($5e5d1b10c766041f$var$_start4.z, $5e5d1b10c766041f$var$_end4.z, param);
        const isInClipSpace = zPos >= -1 && zPos <= 1;
        const isInside = $5e5d1b10c766041f$var$_ssOrigin3.distanceTo($5e5d1b10c766041f$var$_closestPoint) < $5e5d1b10c766041f$var$_lineWidth * 0.5;
        if (isInClipSpace && isInside) {
            $5e5d1b10c766041f$var$_line.start.fromBufferAttribute(instanceStart, i);
            $5e5d1b10c766041f$var$_line.end.fromBufferAttribute(instanceEnd, i);
            $5e5d1b10c766041f$var$_line.start.applyMatrix4(matrixWorld);
            $5e5d1b10c766041f$var$_line.end.applyMatrix4(matrixWorld);
            const pointOnLine = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
            const point = new (0, $d5b85d29c0b78636$export$64b5c384219d3699)();
            $5e5d1b10c766041f$var$_ray.distanceSqToSegment($5e5d1b10c766041f$var$_line.start, $5e5d1b10c766041f$var$_line.end, point, pointOnLine);
            intersects.push({
                point: point,
                pointOnLine: pointOnLine,
                distance: $5e5d1b10c766041f$var$_ray.origin.distanceTo(point),
                object: lineSegments,
                face: null,
                faceIndex: i,
                uv: null,
                uv1: null
            });
        }
    }
}
class $5e5d1b10c766041f$export$6eda8f258bdba8c5 extends (0, $d5b85d29c0b78636$export$e176487c05830cc5) {
    constructor(geometry = new (0, $e4bd4b396d3c4aec$export$5b1256aa5274bf8)(), material = new (0, $21dd365b363a2479$export$d19cd1378966f3d3)({
        color: Math.random() * 0xffffff
    })){
        super(geometry, material);
        this.isLineSegments2 = true;
        this.type = 'LineSegments2';
    }
    // for backwards-compatibility, but could be a method of LineSegmentsGeometry...
    computeLineDistances() {
        const geometry = this.geometry;
        const instanceStart = geometry.attributes.instanceStart;
        const instanceEnd = geometry.attributes.instanceEnd;
        const lineDistances = new Float32Array(2 * instanceStart.count);
        for(let i = 0, j = 0, l = instanceStart.count; i < l; i++, j += 2){
            $5e5d1b10c766041f$var$_start.fromBufferAttribute(instanceStart, i);
            $5e5d1b10c766041f$var$_end.fromBufferAttribute(instanceEnd, i);
            lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1];
            lineDistances[j + 1] = lineDistances[j] + $5e5d1b10c766041f$var$_start.distanceTo($5e5d1b10c766041f$var$_end);
        }
        const instanceDistanceBuffer = new (0, $d5b85d29c0b78636$export$25ec0e1af1389358)(lineDistances, 2, 1); // d0, d1
        geometry.setAttribute('instanceDistanceStart', new (0, $d5b85d29c0b78636$export$920b6d07334599c7)(instanceDistanceBuffer, 1, 0)); // d0
        geometry.setAttribute('instanceDistanceEnd', new (0, $d5b85d29c0b78636$export$920b6d07334599c7)(instanceDistanceBuffer, 1, 1)); // d1
        return this;
    }
    raycast(raycaster, intersects) {
        const worldUnits = this.material.worldUnits;
        const camera = raycaster.camera;
        if (camera === null && !worldUnits) console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.');
        const threshold = raycaster.params.Line2 !== undefined ? raycaster.params.Line2.threshold || 0 : 0;
        $5e5d1b10c766041f$var$_ray = raycaster.ray;
        const matrixWorld = this.matrixWorld;
        const geometry = this.geometry;
        const material = this.material;
        $5e5d1b10c766041f$var$_lineWidth = material.linewidth + threshold;
        // check if we intersect the sphere bounds
        if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
        $5e5d1b10c766041f$var$_sphere.copy(geometry.boundingSphere).applyMatrix4(matrixWorld);
        // increase the sphere bounds by the worst case line screen space width
        let sphereMargin;
        if (worldUnits) sphereMargin = $5e5d1b10c766041f$var$_lineWidth * 0.5;
        else {
            const distanceToSphere = Math.max(camera.near, $5e5d1b10c766041f$var$_sphere.distanceToPoint($5e5d1b10c766041f$var$_ray.origin));
            sphereMargin = $5e5d1b10c766041f$var$getWorldSpaceHalfWidth(camera, distanceToSphere, material.resolution);
        }
        $5e5d1b10c766041f$var$_sphere.radius += sphereMargin;
        if ($5e5d1b10c766041f$var$_ray.intersectsSphere($5e5d1b10c766041f$var$_sphere) === false) return;
        // check if we intersect the box bounds
        if (geometry.boundingBox === null) geometry.computeBoundingBox();
        $5e5d1b10c766041f$var$_box.copy(geometry.boundingBox).applyMatrix4(matrixWorld);
        // increase the box bounds by the worst case line width
        let boxMargin;
        if (worldUnits) boxMargin = $5e5d1b10c766041f$var$_lineWidth * 0.5;
        else {
            const distanceToBox = Math.max(camera.near, $5e5d1b10c766041f$var$_box.distanceToPoint($5e5d1b10c766041f$var$_ray.origin));
            boxMargin = $5e5d1b10c766041f$var$getWorldSpaceHalfWidth(camera, distanceToBox, material.resolution);
        }
        $5e5d1b10c766041f$var$_box.expandByScalar(boxMargin);
        if ($5e5d1b10c766041f$var$_ray.intersectsBox($5e5d1b10c766041f$var$_box) === false) return;
        if (worldUnits) $5e5d1b10c766041f$var$raycastWorldUnits(this, intersects);
        else $5e5d1b10c766041f$var$raycastScreenSpace(this, camera, intersects);
    }
    onBeforeRender(renderer) {
        const uniforms = this.material.uniforms;
        if (uniforms && uniforms.resolution) {
            renderer.getViewport($5e5d1b10c766041f$var$_viewport);
            this.material.uniforms.resolution.value.set($5e5d1b10c766041f$var$_viewport.z, $5e5d1b10c766041f$var$_viewport.w);
        }
    }
}



class $a066acd1ca5dbf6e$export$dcc17b59d0a74bb5 extends (0, $e4bd4b396d3c4aec$export$5b1256aa5274bf8) {
    constructor(){
        super();
        this.isLineGeometry = true;
        this.type = 'LineGeometry';
    }
    setPositions(array) {
        // converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
        const length = array.length - 3;
        const points = new Float32Array(2 * length);
        for(let i = 0; i < length; i += 3){
            points[2 * i] = array[i];
            points[2 * i + 1] = array[i + 1];
            points[2 * i + 2] = array[i + 2];
            points[2 * i + 3] = array[i + 3];
            points[2 * i + 4] = array[i + 4];
            points[2 * i + 5] = array[i + 5];
        }
        super.setPositions(points);
        return this;
    }
    setColors(array) {
        // converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
        const length = array.length - 3;
        const colors = new Float32Array(2 * length);
        for(let i = 0; i < length; i += 3){
            colors[2 * i] = array[i];
            colors[2 * i + 1] = array[i + 1];
            colors[2 * i + 2] = array[i + 2];
            colors[2 * i + 3] = array[i + 3];
            colors[2 * i + 4] = array[i + 4];
            colors[2 * i + 5] = array[i + 5];
        }
        super.setColors(colors);
        return this;
    }
    setFromPoints(points) {
        // converts a vector3 or vector2 array to pairs format
        const length = points.length - 1;
        const positions = new Float32Array(6 * length);
        for(let i = 0; i < length; i++){
            positions[6 * i] = points[i].x;
            positions[6 * i + 1] = points[i].y;
            positions[6 * i + 2] = points[i].z || 0;
            positions[6 * i + 3] = points[i + 1].x;
            positions[6 * i + 4] = points[i + 1].y;
            positions[6 * i + 5] = points[i + 1].z || 0;
        }
        super.setPositions(positions);
        return this;
    }
    fromLine(line) {
        const geometry = line.geometry;
        this.setPositions(geometry.attributes.position.array); // assumes non-indexed
        // set colors, maybe
        return this;
    }
}



class $895efaa1118dae27$export$4e6fcde58d84e955 extends (0, $5e5d1b10c766041f$export$6eda8f258bdba8c5) {
    constructor(geometry = new (0, $a066acd1ca5dbf6e$export$dcc17b59d0a74bb5)(), material = new (0, $21dd365b363a2479$export$d19cd1378966f3d3)({
        color: Math.random() * 0xffffff
    })){
        super(geometry, material);
        this.isLine2 = true;
        this.type = 'Line2';
    }
}




gsap.defaults({
    overwrite: "auto"
});
function $177d6097cd356643$var$remap(number, inMin, inMax, outMin, outMax) {
    return (number - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
}
const $177d6097cd356643$var$NUM_TEXTURES = 4;
const $177d6097cd356643$var$ICON_X_LOC = -0.4;
const $177d6097cd356643$var$CHECK_LOCS = {
    x: 0.8,
    y: 0.4,
    off: 0.125
};
let $177d6097cd356643$var$iconAITexture, $177d6097cd356643$var$iconCloudTexture, $177d6097cd356643$var$iconDBTexture, $177d6097cd356643$var$iconCheckTexture;
let $177d6097cd356643$var$iconIndex = 0;
let $177d6097cd356643$var$textureCount = 0;
const $177d6097cd356643$var$vpTextureLoader = new $d5b85d29c0b78636$export$fd1bfc71f64c538c();
var $86d72fa7067cc74e$exports = {};

$86d72fa7067cc74e$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "homegrown-1.d8782a51.png";


$177d6097cd356643$var$vpTextureLoader.load(new URL($86d72fa7067cc74e$exports), function(texture) {
    texture.colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa;
    $177d6097cd356643$var$iconDBTexture = texture;
    $177d6097cd356643$var$buildIcons();
});
var $b2cf00b0aa00811b$exports = {};

$b2cf00b0aa00811b$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "homegrown-4.65054a77.png";


$177d6097cd356643$var$vpTextureLoader.load(new URL($b2cf00b0aa00811b$exports), function(texture) {
    texture.colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa;
    $177d6097cd356643$var$iconCloudTexture = texture;
    $177d6097cd356643$var$buildIcons();
});
var $36cfa8997f47174b$exports = {};

$36cfa8997f47174b$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "homegrown-6.b1ebcf6f.png";


$177d6097cd356643$var$vpTextureLoader.load(new URL($36cfa8997f47174b$exports), function(texture) {
    texture.colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa;
    $177d6097cd356643$var$iconAITexture = texture;
    $177d6097cd356643$var$buildIcons();
});
var $c1afe27ec4b3b192$exports = {};

$c1afe27ec4b3b192$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "valueprop-icon-check.62708038.png";


$177d6097cd356643$var$vpTextureLoader.load(new URL($c1afe27ec4b3b192$exports), function(texture) {
    texture.colorSpace = $d5b85d29c0b78636$export$561f394b24edfcaa;
    $177d6097cd356643$var$iconCheckTexture = texture;
    $177d6097cd356643$var$buildIcons();
});
const $177d6097cd356643$var$MESH_D = 0.25;
const $177d6097cd356643$var$SHAPE_D = 0.5;
const $177d6097cd356643$var$MESH_S = 1.35;
let $177d6097cd356643$var$opacityItems = [];
let $177d6097cd356643$var$meshCheck1, $177d6097cd356643$var$meshCheck2, $177d6097cd356643$var$meshCheck3;
let $177d6097cd356643$var$iconMeshesGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
const $177d6097cd356643$var$buildIcons = ()=>{
    $177d6097cd356643$var$textureCount++;
    if ($177d6097cd356643$var$textureCount < $177d6097cd356643$var$NUM_TEXTURES) return;
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$iconMeshesGroup);
    let geom = new $d5b85d29c0b78636$export$967d831af31f69ce($177d6097cd356643$var$MESH_D, $177d6097cd356643$var$MESH_D, 8, 8);
    let mat = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
        transparent: true,
        map: $177d6097cd356643$var$iconAITexture
    });
    mat.opacity = 0;
    $177d6097cd356643$var$iconMeshesGroup.add(new $d5b85d29c0b78636$export$e176487c05830cc5(geom, mat));
    geom = new $d5b85d29c0b78636$export$967d831af31f69ce($177d6097cd356643$var$MESH_D, $177d6097cd356643$var$MESH_D, 8, 8);
    mat = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
        transparent: true,
        map: $177d6097cd356643$var$iconCloudTexture
    });
    mat.opacity = 0;
    $177d6097cd356643$var$iconMeshesGroup.add(new $d5b85d29c0b78636$export$e176487c05830cc5(geom, mat));
    geom = new $d5b85d29c0b78636$export$967d831af31f69ce($177d6097cd356643$var$MESH_D, $177d6097cd356643$var$MESH_D, 8, 8);
    mat = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
        transparent: true,
        map: $177d6097cd356643$var$iconDBTexture
    });
    mat.opacity = 0;
    $177d6097cd356643$var$iconMeshesGroup.add(new $d5b85d29c0b78636$export$e176487c05830cc5(geom, mat));
    geom = new $d5b85d29c0b78636$export$967d831af31f69ce($177d6097cd356643$var$MESH_D * 3, $177d6097cd356643$var$MESH_D * 3, 8, 8);
    mat = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
        transparent: true,
        map: $177d6097cd356643$var$iconCheckTexture
    });
    mat.opacity = 0;
    $177d6097cd356643$var$meshCheck1 = new $d5b85d29c0b78636$export$e176487c05830cc5(geom, mat);
    $177d6097cd356643$var$meshCheck1.material.opacity = 0;
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$meshCheck1);
    geom = new $d5b85d29c0b78636$export$967d831af31f69ce($177d6097cd356643$var$MESH_D * 3, $177d6097cd356643$var$MESH_D * 3, 8, 8);
    mat = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
        transparent: true,
        map: $177d6097cd356643$var$iconCheckTexture
    });
    mat.opacity = 0;
    $177d6097cd356643$var$meshCheck2 = new $d5b85d29c0b78636$export$e176487c05830cc5(geom, mat);
    $177d6097cd356643$var$meshCheck2.material.opacity = 0;
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$meshCheck2);
    geom = new $d5b85d29c0b78636$export$967d831af31f69ce($177d6097cd356643$var$MESH_D * 3, $177d6097cd356643$var$MESH_D * 3, 8, 8);
    mat = new $d5b85d29c0b78636$export$55cbcc9b622fe1f5({
        transparent: true,
        map: $177d6097cd356643$var$iconCheckTexture
    });
    mat.opacity = 0;
    $177d6097cd356643$var$meshCheck3 = new $d5b85d29c0b78636$export$e176487c05830cc5(geom, mat);
    $177d6097cd356643$var$meshCheck3.material.opacity = 0;
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$meshCheck3);
    $177d6097cd356643$var$iconMeshesGroup.children[0].scale.set($177d6097cd356643$var$MESH_S, $177d6097cd356643$var$MESH_S, $177d6097cd356643$var$MESH_S);
    $177d6097cd356643$var$iconMeshesGroup.children[1].scale.set($177d6097cd356643$var$MESH_S, $177d6097cd356643$var$MESH_S, $177d6097cd356643$var$MESH_S);
    $177d6097cd356643$var$iconMeshesGroup.children[2].scale.set($177d6097cd356643$var$MESH_S, $177d6097cd356643$var$MESH_S, $177d6097cd356643$var$MESH_S);
    $177d6097cd356643$var$meshCheck1.position.set($177d6097cd356643$var$CHECK_LOCS.x, $177d6097cd356643$var$CHECK_LOCS.y + $177d6097cd356643$var$CHECK_LOCS.off);
    $177d6097cd356643$var$meshCheck2.position.set($177d6097cd356643$var$CHECK_LOCS.x, $177d6097cd356643$var$CHECK_LOCS.off);
    $177d6097cd356643$var$meshCheck3.position.set($177d6097cd356643$var$CHECK_LOCS.x, -$177d6097cd356643$var$CHECK_LOCS.y + $177d6097cd356643$var$CHECK_LOCS.off);
    $177d6097cd356643$var$loadFrameLines();
    $177d6097cd356643$var$loadFrames();
    $177d6097cd356643$var$loadMorphShapes();
    $177d6097cd356643$var$setupTimelines();
    $177d6097cd356643$var$handleMobile();
    const pBar = document.querySelector(`#s-value-prop-1 .value-prop-progress-container${$177d6097cd356643$var$isMobile() ? "-mobile" : ""} .progress-active`);
    pBar.style.width = `0%`;
};
const $177d6097cd356643$var$xOffset = -1;
const $177d6097cd356643$export$16c5ba6a7cb25d77 = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
const $177d6097cd356643$var$containerGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
const $177d6097cd356643$export$4887ad270a8312d5 = (scene)=>{
    $177d6097cd356643$var$containerGroup.position.x = $177d6097cd356643$var$xOffset;
    $177d6097cd356643$export$16c5ba6a7cb25d77.add($177d6097cd356643$var$containerGroup);
    scene.add($177d6097cd356643$export$16c5ba6a7cb25d77);
};
const $177d6097cd356643$export$e207fdd04ad31b0 = (scene)=>{
    scene.remove($177d6097cd356643$export$16c5ba6a7cb25d77);
    $177d6097cd356643$export$16c5ba6a7cb25d77.traverse((child)=>{
        if (child instanceof $d5b85d29c0b78636$export$e176487c05830cc5) {
            child.geometry.dispose();
            child.material.dispose();
        }
    });
};
const $177d6097cd356643$var$numShapes = 6;
let $177d6097cd356643$var$props = {
    tension: 0,
    baseTension: 0,
    targetTension: 0.8,
    lineWidth: 2
};
let $177d6097cd356643$var$square, $177d6097cd356643$var$morphShapeGeometry;
let $177d6097cd356643$var$morphShapesGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
$177d6097cd356643$var$morphShapesGroup.position.z = 1;
$177d6097cd356643$var$morphShapesGroup.position.x = 0.15;
const $177d6097cd356643$var$loadMorphShapes = ()=>{
    $177d6097cd356643$var$square = new $d5b85d29c0b78636$export$b9146b27c24b744c([
        new $d5b85d29c0b78636$export$64b5c384219d3699(-$177d6097cd356643$var$SHAPE_D, $177d6097cd356643$var$SHAPE_D, 0),
        new $d5b85d29c0b78636$export$64b5c384219d3699($177d6097cd356643$var$SHAPE_D, $177d6097cd356643$var$SHAPE_D, 0),
        new $d5b85d29c0b78636$export$64b5c384219d3699($177d6097cd356643$var$SHAPE_D, -$177d6097cd356643$var$SHAPE_D, 0),
        new $d5b85d29c0b78636$export$64b5c384219d3699(-$177d6097cd356643$var$SHAPE_D, -$177d6097cd356643$var$SHAPE_D, 0)
    ]);
    $177d6097cd356643$var$square.closed = true;
    $177d6097cd356643$var$square.curveType = "catmullrom";
    $177d6097cd356643$var$square.tension = $177d6097cd356643$var$props.baseTension;
    const positions = $177d6097cd356643$var$getUpdatedPositions($177d6097cd356643$var$square);
    $177d6097cd356643$var$morphShapeGeometry = new (0, $a066acd1ca5dbf6e$export$dcc17b59d0a74bb5)();
    $177d6097cd356643$var$morphShapeGeometry.setPositions(positions);
    for(let i = 0; i < $177d6097cd356643$var$numShapes; i++){
        const matLine = new (0, $21dd365b363a2479$export$d19cd1378966f3d3)({
            color: 0xffffff,
            linewidth: $177d6097cd356643$var$props.lineWidth,
            transparent: true
        });
        matLine.opacity = 0;
        const shape = new (0, $895efaa1118dae27$export$4e6fcde58d84e955)($177d6097cd356643$var$morphShapeGeometry, matLine);
        $177d6097cd356643$var$morphShapesGroup.add(shape);
        if (i == 1) $177d6097cd356643$var$morphShapesGroup.children[i].scale.set($177d6097cd356643$var$props.targetTension, $177d6097cd356643$var$props.targetTension, $177d6097cd356643$var$props.targetTension);
    }
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$morphShapesGroup);
};
const $177d6097cd356643$var$numFrames = 3;
const $177d6097cd356643$var$FRAME_D = 0.17;
let $177d6097cd356643$var$framesGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
const $177d6097cd356643$var$loadFrames = ()=>{
    for(let i = 0; i < $177d6097cd356643$var$numFrames; i++){
        const square = new $d5b85d29c0b78636$export$b9146b27c24b744c([
            new $d5b85d29c0b78636$export$64b5c384219d3699(-$177d6097cd356643$var$FRAME_D - $177d6097cd356643$var$ICON_X_LOC, $177d6097cd356643$var$FRAME_D, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699($177d6097cd356643$var$FRAME_D - $177d6097cd356643$var$ICON_X_LOC, $177d6097cd356643$var$FRAME_D, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699($177d6097cd356643$var$FRAME_D - $177d6097cd356643$var$ICON_X_LOC, -$177d6097cd356643$var$FRAME_D, 0),
            new $d5b85d29c0b78636$export$64b5c384219d3699(-$177d6097cd356643$var$FRAME_D - $177d6097cd356643$var$ICON_X_LOC, -$177d6097cd356643$var$FRAME_D, 0)
        ]);
        square.closed = true;
        square.curveType = "catmullrom";
        square.tension = $177d6097cd356643$var$props.baseTension;
        const positions = $177d6097cd356643$var$getUpdatedPositions(square);
        const morphShapeGeometry = new (0, $a066acd1ca5dbf6e$export$dcc17b59d0a74bb5)();
        morphShapeGeometry.setPositions(positions);
        const matLine = new (0, $21dd365b363a2479$export$d19cd1378966f3d3)({
            color: 0x3d3c40,
            linewidth: $177d6097cd356643$var$props.lineWidth,
            transparent: true
        });
        const shape = new (0, $895efaa1118dae27$export$4e6fcde58d84e955)(morphShapeGeometry, matLine);
        matLine.opacity = 0;
        shape.position.y = i == 0 ? $177d6097cd356643$var$CHECK_LOCS.y : i == 1 ? 0 : -$177d6097cd356643$var$CHECK_LOCS.y;
        $177d6097cd356643$var$framesGroup.add(shape);
    }
    $177d6097cd356643$var$framesGroup.position.x = $177d6097cd356643$var$ICON_X_LOC * 1.4;
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$framesGroup);
};
const $177d6097cd356643$var$numFramesLines = 2;
let $177d6097cd356643$var$frameLinesGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
const $177d6097cd356643$var$loadFrameLines = ()=>{
    for(let i = 0; i < $177d6097cd356643$var$numFrames; i++){
        const innerGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
        for(let j = 0; j < $177d6097cd356643$var$numFramesLines; j++){
            const square = new $d5b85d29c0b78636$export$b9146b27c24b744c([
                new $d5b85d29c0b78636$export$64b5c384219d3699(-$177d6097cd356643$var$FRAME_D - $177d6097cd356643$var$ICON_X_LOC, $177d6097cd356643$var$FRAME_D, 0),
                new $d5b85d29c0b78636$export$64b5c384219d3699($177d6097cd356643$var$FRAME_D - $177d6097cd356643$var$ICON_X_LOC * 2, $177d6097cd356643$var$FRAME_D, 0)
            ]);
            square.closed = true;
            square.curveType = "catmullrom";
            square.tension = $177d6097cd356643$var$props.baseTension;
            const positions = $177d6097cd356643$var$getUpdatedPositions(square);
            const morphShapeGeometry = new (0, $a066acd1ca5dbf6e$export$dcc17b59d0a74bb5)();
            morphShapeGeometry.setPositions(positions, 2);
            const matLine = new (0, $21dd365b363a2479$export$d19cd1378966f3d3)({
                color: 0x3d3c40,
                linewidth: $177d6097cd356643$var$props.lineWidth * 6,
                transparent: true
            });
            matLine.opacity = 0;
            const shape = new (0, $895efaa1118dae27$export$4e6fcde58d84e955)(morphShapeGeometry, matLine);
            shape.position.x = j == 0 ? 0.12 : 0.21;
            shape.scale.x = j == 0 ? 1 : 0.6;
            shape.position.y = j == 0 ? 0 : -0.08;
            innerGroup.add(shape);
        }
        innerGroup.position.y = i == 0 ? $177d6097cd356643$var$CHECK_LOCS.y : i == 1 ? 0 : -$177d6097cd356643$var$CHECK_LOCS.y;
        $177d6097cd356643$var$frameLinesGroup.add(innerGroup);
    }
    $177d6097cd356643$var$frameLinesGroup.position.x = $177d6097cd356643$var$ICON_X_LOC * 1.4;
    $177d6097cd356643$var$frameLinesGroup.position.y = -$177d6097cd356643$var$CHECK_LOCS.y * 0.3;
    $177d6097cd356643$var$containerGroup.add($177d6097cd356643$var$frameLinesGroup);
};
let $177d6097cd356643$var$prevPhase = -1;
const $177d6097cd356643$export$2417ba97adc3c044 = (phase, progress)=>{
    // console.log(phase, progress.toFixed(1))
    $177d6097cd356643$var$animateProgressBar(phase, progress);
    if ($177d6097cd356643$var$prevPhase != phase) {
        const scrollingForward = $177d6097cd356643$var$prevPhase < phase;
        // console.log(`phase change from ${prevPhase} to ${phase}`)
        $177d6097cd356643$var$updateOpacityItems(phase == 0);
        $177d6097cd356643$var$setArrangement(phase, scrollingForward);
        $177d6097cd356643$var$prevPhase = phase;
    }
    switch(phase){
        case 0:
            $177d6097cd356643$var$setOpacity(progress > 0.75 ? $177d6097cd356643$var$remap(progress, 0.75, 1, 0, 1) : 0);
            break;
        case 4:
            $177d6097cd356643$var$setOpacity(progress < 0.25 ? $177d6097cd356643$var$remap(progress, 0, 0.25, 1, 0) : 0);
            break;
    }
};
const $177d6097cd356643$var$animateProgressBar = (phase, progress)=>{
    if (phase < 1 || phase > 3) return;
    const pBar = document.querySelector(`#s-value-prop-${phase} .value-prop-progress-container${$177d6097cd356643$var$isMobile() ? "-mobile" : ""} .progress-active`);
    pBar.style.width = `${progress.toFixed(2) * 100}%`;
};
const $177d6097cd356643$var$setArrangement = (phase, scrollingForward)=>{
    // console.log(`phase: ${phase}, forward: ${scrollingForward}`);
    switch(phase){
        case 0:
            if (!scrollingForward) {
                if ($177d6097cd356643$var$arrangement3MorphShapes.isActive()) {
                    $177d6097cd356643$var$arrangement3MorphShapes.progress(0);
                    $177d6097cd356643$var$arrangement3MorphShapes.pause();
                }
                if ($177d6097cd356643$var$arrangement2MorphShapes.isActive()) {
                    $177d6097cd356643$var$arrangement2MorphShapes.progress(0);
                    $177d6097cd356643$var$arrangement2MorphShapes.pause();
                }
                $177d6097cd356643$var$clearArrangement1Loops();
                $177d6097cd356643$var$hardResetMorphShapes(false);
            }
            break;
        case 1:
            if (scrollingForward) $177d6097cd356643$var$arrangement1SquareLoop.restart();
            else {
                if ($177d6097cd356643$var$arrangement3Icons.isActive()) {
                    $177d6097cd356643$var$arrangement3Icons.progress(0);
                    $177d6097cd356643$var$arrangement3Icons.pause();
                }
                $177d6097cd356643$var$arrangement2MorphShapes.reverse();
                window.setTimeout(()=>{
                    if ($177d6097cd356643$var$prevPhase == 1) $177d6097cd356643$var$arrangement1SquareLoop.restart();
                }, $177d6097cd356643$var$tlDurations.arrangement2MorphShapes * 1000);
                $177d6097cd356643$var$arrangement2Icons.pause();
                $177d6097cd356643$var$arrangement2IconsZLoop.pause();
                $177d6097cd356643$var$arrangement1Icons.restart();
            }
            break;
        case 2:
            $177d6097cd356643$var$iconIndex = 0;
            if (scrollingForward) {
                $177d6097cd356643$var$clearArrangement1Loops();
                $177d6097cd356643$var$arrangement2MorphShapes.play(0);
                $177d6097cd356643$var$arrangement2Icons.play(0);
                $177d6097cd356643$var$arrangement2IconsZLoop.play(0);
            } else {
                if ($177d6097cd356643$var$arrangement3Frames.isActive()) $177d6097cd356643$var$arrangement3Frames.pause();
                $177d6097cd356643$var$arrangement3MorphShapes.reverse();
                $177d6097cd356643$var$arrangement3Icons.reverse();
                window.setTimeout(()=>{
                    if ($177d6097cd356643$var$prevPhase == 2) $177d6097cd356643$var$arrangement2IconsZLoop.play(0);
                }, $177d6097cd356643$var$tlDurations.arrangement3Icons * 1000);
                $177d6097cd356643$var$arrangement3FramesHide.restart();
            }
            break;
        case 3:
            if (scrollingForward) {
                $177d6097cd356643$var$arrangement2MorphShapes.progress(1);
                $177d6097cd356643$var$arrangement2MorphShapes.pause();
                $177d6097cd356643$var$arrangement2Icons.progress(1);
                $177d6097cd356643$var$arrangement2Icons.pause();
                $177d6097cd356643$var$arrangement2IconsZLoop.progress(0);
                $177d6097cd356643$var$arrangement2IconsZLoop.pause();
                $177d6097cd356643$var$arrangement3MorphShapes.restart();
                $177d6097cd356643$var$arrangement3Icons.restart();
                $177d6097cd356643$var$arrangement3Frames.restart();
            }
            break;
        case 4:
            if ($177d6097cd356643$var$arrangement3Frames.isActive()) $177d6097cd356643$var$arrangement3Frames.progress(1);
            break;
    }
};
let $177d6097cd356643$var$arrangement1SquareLoop, $177d6097cd356643$var$arrangement1Icon0Loop, $177d6097cd356643$var$arrangement1Icon1Loop, $177d6097cd356643$var$arrangement1Icons, $177d6097cd356643$var$arrangement1Icon2Loop, $177d6097cd356643$var$arrangement2MorphShapes, $177d6097cd356643$var$arrangement2MorphShapeGroupRotation, $177d6097cd356643$var$arrangement2Icons, $177d6097cd356643$var$arrangement2IconsZLoop, $177d6097cd356643$var$arrangement3MorphShapes, $177d6097cd356643$var$arrangement3Icons, $177d6097cd356643$var$arrangement3Frames, $177d6097cd356643$var$arrangement3FramesHide;
const $177d6097cd356643$var$tlDurations = {
    arrangement2MorphShapes: 0.3,
    arrangement3MorphShapes: 0.3,
    arrangement3Icons: 0.45
};
const $177d6097cd356643$var$FRAME_SCALE = 4.5;
gsap.defaults({
    overwrite: "true"
});
const $177d6097cd356643$var$setupTimelines = ()=>{
    $177d6097cd356643$var$arrangement1Icon2Loop = gsap.timeline();
    $177d6097cd356643$var$arrangement1Icon2Loop.pause();
    $177d6097cd356643$var$arrangement1Icon2Loop.fromTo($177d6097cd356643$var$iconMeshesGroup.children[2].rotation, {
        y: 0
    }, {
        y: -Math.PI / 180 * 180,
        duration: 0.5,
        ease: "power1.easeIn"
    }, 1);
    $177d6097cd356643$var$arrangement1Icon2Loop.to($177d6097cd356643$var$iconMeshesGroup.children[2].material, {
        opacity: 0,
        duration: 0,
        delay: 0.5
    }, 1);
    $177d6097cd356643$var$arrangement1Icon2Loop.to($177d6097cd356643$var$iconMeshesGroup.children[0].material, {
        opacity: 1,
        duration: 0,
        delay: 0
    }, 1);
    $177d6097cd356643$var$arrangement1Icon2Loop.fromTo($177d6097cd356643$var$iconMeshesGroup.children[0].rotation, {
        y: Math.PI / 180 * 180
    }, {
        y: 0,
        duration: 0.5,
        ease: "power1.easeOut"
    }, 1);
    $177d6097cd356643$var$arrangement1Icon1Loop = gsap.timeline();
    $177d6097cd356643$var$arrangement1Icon1Loop.pause();
    $177d6097cd356643$var$arrangement1Icon1Loop.fromTo($177d6097cd356643$var$iconMeshesGroup.children[1].rotation, {
        y: 0
    }, {
        y: -Math.PI / 180 * 180,
        duration: 0.5,
        ease: "power1.easeIn"
    }, 1);
    $177d6097cd356643$var$arrangement1Icon1Loop.to($177d6097cd356643$var$iconMeshesGroup.children[1].material, {
        opacity: 0,
        duration: 0,
        delay: 0.5
    }, 1);
    $177d6097cd356643$var$arrangement1Icon1Loop.to($177d6097cd356643$var$iconMeshesGroup.children[2].material, {
        opacity: 1,
        duration: 0,
        delay: 0
    }, 1);
    $177d6097cd356643$var$arrangement1Icon1Loop.fromTo($177d6097cd356643$var$iconMeshesGroup.children[2].rotation, {
        y: Math.PI / 180 * 180
    }, {
        y: 0,
        duration: 0.5,
        ease: "power1.easeOut"
    }, 1);
    $177d6097cd356643$var$arrangement1Icon0Loop = gsap.timeline();
    $177d6097cd356643$var$arrangement1Icon0Loop.pause();
    $177d6097cd356643$var$arrangement1Icon0Loop.fromTo($177d6097cd356643$var$iconMeshesGroup.children[0].rotation, {
        y: 0
    }, {
        y: -Math.PI / 180 * 180,
        duration: 0.5,
        ease: "power1.easeIn"
    }, 1);
    $177d6097cd356643$var$arrangement1Icon0Loop.to($177d6097cd356643$var$iconMeshesGroup.children[0].material, {
        opacity: 0,
        duration: 0,
        delay: 0.5
    }, 1);
    $177d6097cd356643$var$arrangement1Icon0Loop.to($177d6097cd356643$var$iconMeshesGroup.children[1].material, {
        opacity: 1,
        duration: 0,
        delay: 0
    }, 1);
    $177d6097cd356643$var$arrangement1Icon0Loop.fromTo($177d6097cd356643$var$iconMeshesGroup.children[1].rotation, {
        y: Math.PI / 180 * 180
    }, {
        y: 0,
        duration: 0.5,
        ease: "power1.easeOut"
    }, 1);
    $177d6097cd356643$var$arrangement1SquareLoop = gsap.timeline({
        repeat: -1,
        repeatDelay: 0.5
    });
    $177d6097cd356643$var$arrangement1SquareLoop.pause();
    $177d6097cd356643$var$arrangement1SquareLoop.to($177d6097cd356643$var$morphShapesGroup.children[0].rotation, {
        y: -Math.PI / 180 * 180,
        ease: "back.inOut(2)",
        duration: 1.5,
        delay: 0.5
    });
    $177d6097cd356643$var$arrangement1SquareLoop.to($177d6097cd356643$var$morphShapesGroup.children[1].rotation, {
        y: -Math.PI / 180 * 180,
        ease: "back.inOut(2)",
        duration: 2,
        onStart: ()=>{
            switch($177d6097cd356643$var$iconIndex){
                case 0:
                    $177d6097cd356643$var$arrangement1Icon0Loop.play(0);
                    $177d6097cd356643$var$iconIndex = 1;
                    break;
                case 1:
                    $177d6097cd356643$var$arrangement1Icon1Loop.play(0);
                    $177d6097cd356643$var$iconIndex = 2;
                    break;
                case 2:
                    $177d6097cd356643$var$arrangement1Icon2Loop.play(0);
                    $177d6097cd356643$var$iconIndex = 0;
                    break;
            }
        }
    }, 0);
    $177d6097cd356643$var$arrangement1Icons = gsap.timeline();
    $177d6097cd356643$var$arrangement1Icons.pause();
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        x: 0,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        y: 0,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        z: 0,
        ease: "power1.inOut",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].material, {
        opacity: 0,
        duration: 0.3
    }, 0.1);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        x: 0,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        y: 0,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        z: 0,
        ease: "power1.inOut",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].material, {
        opacity: 0,
        duration: 0.3
    }, 0.1);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        y: 0,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement1Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        z: 0,
        ease: "power1.inOut",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement2MorphShapes = gsap.timeline();
    $177d6097cd356643$var$arrangement2MorphShapes.pause();
    $177d6097cd356643$var$arrangement2MorphShapes.fromTo($177d6097cd356643$var$props, {
        tension: $177d6097cd356643$var$props.baseTension
    }, {
        tension: $177d6097cd356643$var$props.targetTension,
        duration: $177d6097cd356643$var$tlDurations.arrangement2MorphShapes,
        onUpdate: ()=>{
            if (!$177d6097cd356643$var$arrangement2MorphShapes.isActive()) return;
            $177d6097cd356643$var$square.tension = $177d6097cd356643$var$props.tension;
            const positions = $177d6097cd356643$var$getUpdatedPositions($177d6097cd356643$var$square);
            $177d6097cd356643$var$morphShapeGeometry.setPositions(positions);
            const sc = $177d6097cd356643$var$remap($177d6097cd356643$var$props.tension, $177d6097cd356643$var$props.baseTension, $177d6097cd356643$var$props.targetTension, $177d6097cd356643$var$props.targetTension, 1);
            $177d6097cd356643$var$morphShapesGroup.children[1].scale.set(sc, sc, sc);
            const srx = $177d6097cd356643$var$remap($177d6097cd356643$var$props.tension, $177d6097cd356643$var$props.baseTension, $177d6097cd356643$var$props.targetTension, 0, Math.PI / 180 * 40);
            const srz = $177d6097cd356643$var$remap($177d6097cd356643$var$props.tension, $177d6097cd356643$var$props.baseTension, $177d6097cd356643$var$props.targetTension, 0, Math.PI / 180 * 65);
            $177d6097cd356643$var$morphShapesGroup.children.forEach((s, i)=>{
                const sry = Math.PI / 180 * (180 / $177d6097cd356643$var$numShapes) * i;
                s.rotation.set(srx, sry, srz);
                const so = $177d6097cd356643$var$remap($177d6097cd356643$var$props.tension, $177d6097cd356643$var$props.baseTension, $177d6097cd356643$var$props.targetTension, i < 2 ? 1 : 0, 0.3);
                gsap.to(s.material, {
                    opacity: so,
                    duration: 0
                });
            });
        },
        onComplete: ()=>{
            $177d6097cd356643$var$arrangement2MorphShapeGroupRotation.play();
            $177d6097cd356643$var$hardResetMorphShapes(true); //this is necessary because fast-scrolling doesn't always result in the correct final lerp value
        },
        onReverseComplete: ()=>{
            $177d6097cd356643$var$hardResetMorphShapes(false); //this is necessary because calling reverse doesn't always result in the correct final lerp value
        }
    }, 0);
    $177d6097cd356643$var$arrangement2Icons = gsap.timeline();
    $177d6097cd356643$var$arrangement2Icons.pause();
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].material, {
        opacity: 1,
        duration: 0.4
    }, 0.1);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].rotation, {
        y: 0,
        duration: 0
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        x: -0.3,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        y: -0.3,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].material, {
        opacity: 1,
        duration: 0.4
    }, 0.1);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].rotation, {
        y: 0,
        duration: 0
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        x: 0.3,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        y: -0.3,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].material, {
        opacity: 1,
        duration: 0.4
    }, 0.1);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].rotation, {
        y: 0,
        duration: 0
    }, 0);
    $177d6097cd356643$var$arrangement2Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        y: 0.3,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0);
    $177d6097cd356643$var$arrangement2IconsZLoop = gsap.timeline();
    $177d6097cd356643$var$arrangement2IconsZLoop.pause();
    $177d6097cd356643$var$arrangement2IconsZLoop.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        z: 0.3,
        ease: "power1.inOut",
        duration: 1.5,
        yoyo: true,
        repeat: -1
    }, 0);
    $177d6097cd356643$var$arrangement2IconsZLoop.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        z: 0.3,
        ease: "power1.inOut",
        duration: 1.65,
        yoyo: true,
        repeat: -1
    }, 0);
    $177d6097cd356643$var$arrangement2IconsZLoop.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        z: 0.3,
        ease: "power1.inOut",
        duration: 1.8,
        yoyo: true,
        repeat: -1
    }, 0);
    $177d6097cd356643$var$arrangement2MorphShapeGroupRotation = gsap.timeline({
        repeat: -1
    });
    $177d6097cd356643$var$arrangement2MorphShapeGroupRotation.pause();
    $177d6097cd356643$var$arrangement2MorphShapeGroupRotation.to($177d6097cd356643$var$morphShapesGroup.rotation, {
        y: Math.PI / 180 * 360,
        ease: "none",
        duration: 250
    });
    $177d6097cd356643$var$arrangement3MorphShapes = gsap.timeline();
    $177d6097cd356643$var$arrangement3MorphShapes.pause();
    $177d6097cd356643$var$arrangement3MorphShapes.fromTo($177d6097cd356643$var$props, {
        tension: $177d6097cd356643$var$props.baseTension
    }, {
        tension: $177d6097cd356643$var$props.targetTension,
        duration: $177d6097cd356643$var$tlDurations.arrangement3MorphShapes,
        onUpdate: ()=>{
            if (!$177d6097cd356643$var$arrangement3MorphShapes.isActive()) return;
            $177d6097cd356643$var$morphShapesGroup.children.forEach((s, i)=>{
                const sc = $177d6097cd356643$var$remap($177d6097cd356643$var$props.tension, $177d6097cd356643$var$props.baseTension, $177d6097cd356643$var$props.targetTension, 1, 1.2);
                s.scale.set(sc, sc, sc);
                const op = $177d6097cd356643$var$remap($177d6097cd356643$var$props.tension, $177d6097cd356643$var$props.baseTension, $177d6097cd356643$var$props.targetTension, 0.3, 0);
                s.material.opacity = op;
            });
        }
    }, 0);
    $177d6097cd356643$var$arrangement3Icons = gsap.timeline();
    $177d6097cd356643$var$arrangement3Icons.pause();
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        x: $177d6097cd356643$var$ICON_X_LOC,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        y: -$177d6097cd356643$var$CHECK_LOCS.y,
        ease: "back.inOut(2)",
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].position, {
        z: 0,
        duration: 0.3,
        yoyo: false,
        repeat: 0
    }, 0);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].scale, {
        x: 1,
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].scale, {
        y: 1,
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[0].scale, {
        z: 1,
        duration: 0.3
    }, 0);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        x: $177d6097cd356643$var$ICON_X_LOC,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0.1);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        y: 0,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0.1);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].position, {
        z: 0,
        duration: 0.3,
        yoyo: false,
        repeat: 0
    }, 0.1);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].scale, {
        x: 1,
        duration: 0.3
    }, 0.1);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].scale, {
        y: 1,
        duration: 0.3
    }, 0.1);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[1].scale, {
        z: 1,
        duration: 0.3
    }, 0.1);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        x: $177d6097cd356643$var$ICON_X_LOC,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0.15);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        y: $177d6097cd356643$var$CHECK_LOCS.y,
        ease: "back.inOut(2)",
        duration: 0.8
    }, 0.15);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].position, {
        z: 0,
        duration: 0.3,
        yoyo: false,
        repeat: 0
    }, 0.15);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].scale, {
        x: 1,
        duration: 0.3
    }, 0.15);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].scale, {
        y: 1,
        duration: 0.3
    }, 0.15);
    $177d6097cd356643$var$arrangement3Icons.to($177d6097cd356643$var$iconMeshesGroup.children[2].scale, {
        z: 1,
        duration: 0.3
    }, 0.15);
    $177d6097cd356643$var$arrangement3Frames = gsap.timeline();
    $177d6097cd356643$var$arrangement3Frames.pause();
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$meshCheck1.material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.35
    }, 0.5);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$meshCheck1.position, {
        y: $177d6097cd356643$var$CHECK_LOCS.y + $177d6097cd356643$var$CHECK_LOCS.off
    }, {
        y: $177d6097cd356643$var$CHECK_LOCS.y,
        ease: "elastic.out(1,0.2)",
        duration: 1.25
    }, 0.5);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$meshCheck2.material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.35
    }, 0.65);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$meshCheck2.position, {
        y: $177d6097cd356643$var$CHECK_LOCS.off
    }, {
        y: 0,
        ease: "elastic.out(1,0.2)",
        duration: 1.25
    }, 0.65);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$meshCheck3.material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.35
    }, 0.8);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$meshCheck3.position, {
        y: -$177d6097cd356643$var$CHECK_LOCS.y + $177d6097cd356643$var$CHECK_LOCS.off
    }, {
        y: -$177d6097cd356643$var$CHECK_LOCS.y,
        ease: "elastic.out(1,0.2)",
        duration: 1.25
    }, 0.8);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[0].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 0.6);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[1].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 0.9);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[2].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 1.1);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[0].position, {
        x: $177d6097cd356643$var$FRAME_D + $177d6097cd356643$var$ICON_X_LOC
    }, {
        x: ($177d6097cd356643$var$FRAME_D + $177d6097cd356643$var$ICON_X_LOC) * $177d6097cd356643$var$FRAME_SCALE,
        duration: 0.4
    }, 0.6);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[1].position, {
        x: $177d6097cd356643$var$FRAME_D + $177d6097cd356643$var$ICON_X_LOC
    }, {
        x: ($177d6097cd356643$var$FRAME_D + $177d6097cd356643$var$ICON_X_LOC) * $177d6097cd356643$var$FRAME_SCALE,
        duration: 0.4
    }, 0.9);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[2].position, {
        x: $177d6097cd356643$var$FRAME_D + $177d6097cd356643$var$ICON_X_LOC
    }, {
        x: ($177d6097cd356643$var$FRAME_D + $177d6097cd356643$var$ICON_X_LOC) * $177d6097cd356643$var$FRAME_SCALE,
        duration: 0.4
    }, 1.1);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[0].scale, {
        x: 1
    }, {
        x: $177d6097cd356643$var$FRAME_SCALE,
        duration: 0.4
    }, 0.6);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[1].scale, {
        x: 1
    }, {
        x: $177d6097cd356643$var$FRAME_SCALE,
        duration: 0.4
    }, 0.9);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$framesGroup.children[2].scale, {
        x: 1
    }, {
        x: $177d6097cd356643$var$FRAME_SCALE,
        duration: 0.4
    }, 1.1);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$frameLinesGroup.children[0].children[0].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 0.65);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$frameLinesGroup.children[1].children[0].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 0.95);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$frameLinesGroup.children[2].children[0].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 1.15);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$frameLinesGroup.children[0].children[1].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 0.66);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$frameLinesGroup.children[1].children[1].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 0.96);
    $177d6097cd356643$var$arrangement3Frames.fromTo($177d6097cd356643$var$frameLinesGroup.children[2].children[1].material, {
        opacity: 0
    }, {
        opacity: 1,
        duration: 0.4
    }, 1.16);
    $177d6097cd356643$var$arrangement3FramesHide = gsap.timeline();
    $177d6097cd356643$var$arrangement3FramesHide.pause();
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$meshCheck1.material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$meshCheck2.material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$meshCheck3.material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$framesGroup.children[0].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$framesGroup.children[1].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$framesGroup.children[2].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$frameLinesGroup.children[0].children[0].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$frameLinesGroup.children[1].children[0].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$frameLinesGroup.children[2].children[0].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$frameLinesGroup.children[0].children[1].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$frameLinesGroup.children[1].children[1].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
    $177d6097cd356643$var$arrangement3FramesHide.to($177d6097cd356643$var$frameLinesGroup.children[2].children[1].material, {
        opacity: 0,
        duration: 0.25
    }, 0);
};
const $177d6097cd356643$var$clearArrangement1Loops = ()=>{
    $177d6097cd356643$var$arrangement1SquareLoop.progress(0);
    $177d6097cd356643$var$arrangement1SquareLoop.pause();
    if ($177d6097cd356643$var$arrangement1Icon0Loop.isActive()) {
        $177d6097cd356643$var$iconIndex = $177d6097cd356643$var$arrangement1Icon0Loop.progress() < 0.5 ? 0 : 1;
        $177d6097cd356643$var$arrangement1Icon0Loop.progress($177d6097cd356643$var$arrangement1Icon0Loop.progress() < 0.5 ? 0 : 1);
        $177d6097cd356643$var$arrangement1Icon0Loop.pause();
    } else if ($177d6097cd356643$var$arrangement1Icon1Loop.isActive()) {
        $177d6097cd356643$var$iconIndex = $177d6097cd356643$var$arrangement1Icon1Loop.progress() < 0.5 ? 1 : 2;
        $177d6097cd356643$var$arrangement1Icon1Loop.progress($177d6097cd356643$var$arrangement1Icon1Loop.progress() < 0.5 ? 0 : 1);
        $177d6097cd356643$var$arrangement1Icon1Loop.pause();
    } else if ($177d6097cd356643$var$arrangement1Icon2Loop.isActive()) {
        $177d6097cd356643$var$iconIndex = $177d6097cd356643$var$arrangement1Icon2Loop.progress() < 0.5 ? 2 : 0;
        $177d6097cd356643$var$arrangement1Icon2Loop.progress($177d6097cd356643$var$arrangement1Icon2Loop.progress() < 0.5 ? 0 : 1);
        $177d6097cd356643$var$arrangement1Icon2Loop.pause();
    }
    $177d6097cd356643$var$updateOpacityItems(true);
};
const $177d6097cd356643$var$hardResetMorphShapes = (toEnd)=>{
    $177d6097cd356643$var$square.tension = toEnd ? $177d6097cd356643$var$props.targetTension : $177d6097cd356643$var$props.baseTension;
    const positions = $177d6097cd356643$var$getUpdatedPositions($177d6097cd356643$var$square);
    $177d6097cd356643$var$morphShapeGeometry.setPositions(positions);
    if (toEnd) $177d6097cd356643$var$morphShapesGroup.children.forEach((s, i)=>{
        const sry = Math.PI / 180 * (180 / $177d6097cd356643$var$numShapes) * i;
        s.rotation.set(Math.PI / 180 * 40, sry, Math.PI / 180 * 65);
        s.scale.set(1, 1, 1);
    });
    else {
        $177d6097cd356643$var$morphShapesGroup.children.forEach((s, i)=>{
            s.rotation.set(0, 0, 0);
            s.scale.set(1, 1, 1);
            if (i == 1) s.scale.set($177d6097cd356643$var$props.targetTension, $177d6097cd356643$var$props.targetTension, $177d6097cd356643$var$props.targetTension);
            else if (i > 1) s.material.opacity = 0;
        });
        $177d6097cd356643$var$arrangement2MorphShapeGroupRotation.progress(0);
        $177d6097cd356643$var$arrangement2MorphShapeGroupRotation.pause();
    }
};
const $177d6097cd356643$var$getUpdatedPositions = (source, divisions = 1500)=>{
    const point = new $d5b85d29c0b78636$export$64b5c384219d3699();
    const positions = [];
    for(let i = 0, l = divisions; i < l; i++){
        const t = i / l;
        source.getPoint(t, point);
        positions.push(point.x, point.y, point.z);
    }
    return positions;
};
const $177d6097cd356643$var$updateOpacityItems = (forBeginning)=>{
    $177d6097cd356643$var$opacityItems = [];
    if (forBeginning) {
        $177d6097cd356643$var$opacityItems.push($177d6097cd356643$var$morphShapesGroup.children[0]);
        $177d6097cd356643$var$opacityItems.push($177d6097cd356643$var$morphShapesGroup.children[1]);
        $177d6097cd356643$var$opacityItems.push($177d6097cd356643$var$iconMeshesGroup.children[$177d6097cd356643$var$iconIndex]);
    } else {
        $177d6097cd356643$var$iconMeshesGroup.children.forEach((c)=>{
            $177d6097cd356643$var$opacityItems.push(c);
        });
        $177d6097cd356643$var$framesGroup.children.forEach((c)=>{
            $177d6097cd356643$var$opacityItems.push(c);
        });
        $177d6097cd356643$var$frameLinesGroup.children.forEach((c)=>{
            c.children.forEach((sc)=>{
                $177d6097cd356643$var$opacityItems.push(sc);
            });
        });
        $177d6097cd356643$var$opacityItems.push($177d6097cd356643$var$meshCheck1);
        $177d6097cd356643$var$opacityItems.push($177d6097cd356643$var$meshCheck2);
        $177d6097cd356643$var$opacityItems.push($177d6097cd356643$var$meshCheck3);
    }
};
const $177d6097cd356643$var$setOpacity = (o)=>{
    $177d6097cd356643$var$opacityItems.forEach((e)=>{
        e.material.opacity = o;
    });
};
window.addEventListener("resize", ()=>{
    $177d6097cd356643$var$handleMobile();
});
const $177d6097cd356643$var$MOBILE_BREAK = 756;
const $177d6097cd356643$var$isMobile = ()=>{
    return window.innerWidth < $177d6097cd356643$var$MOBILE_BREAK;
};
const $177d6097cd356643$var$handleMobile = ()=>{
    $177d6097cd356643$export$16c5ba6a7cb25d77.position.x = $177d6097cd356643$var$isMobile() ? 0.85 : 0;
    $177d6097cd356643$var$containerGroup.position.y = $177d6097cd356643$var$isMobile() ? 0.3 : 0;
};


var $f5a7455c73851c46$var$pHidden = $f5a7455c73851c46$var$pHidden;
// Helper Funcs
function $f5a7455c73851c46$var$remap(number, inMin, inMax, outMin, outMax) {
    return (number - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
}
const $f5a7455c73851c46$var$randomInt = (min, max)=>{
    return Math.floor(Math.random() * (max - min) + min);
};
const $f5a7455c73851c46$var$randomFloat = (min, max)=>{
    return Math.random() * (max - min) + min;
};
const $f5a7455c73851c46$var$PIXEL_RATIO = Math.min(window.devicePixelRatio, 2);
const $f5a7455c73851c46$var$SIZES = {
    width: window.innerWidth,
    height: window.innerHeight
};
const $f5a7455c73851c46$var$mapVapeAmount = ()=>{
    return $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.vaporAmount, 0, 1, 0.1, $f5a7455c73851c46$var$PARAMS.vaporType >= 2 ? 100 : 25);
};
const $f5a7455c73851c46$var$mapVapeSpeed = ()=>{
    return $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.vaporSpeed, 0, 1, 0, 20);
};
const $f5a7455c73851c46$var$mapVapeIntensity = ()=>{
    return $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.vaporIntensity, 0, 1, 0.5, 1);
};
const $f5a7455c73851c46$var$mapVapeScale = ()=>{
    return $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.vaporScale, 0, 1, 0.002, $f5a7455c73851c46$var$PARAMS.vaporType >= 2 ? 0.5 : 0.2);
};
const $f5a7455c73851c46$var$mapVapeOpacity = ()=>{
    return $f5a7455c73851c46$var$PARAMS.currentKabaOpacity;
};
const $f5a7455c73851c46$var$mapGlitchAngle = ()=>{
    return $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.glitchAngle, 0, 1, -Math.PI, Math.PI);
};
// Objects
const $f5a7455c73851c46$var$PARAMS = {
    starfieldColor: "#894f2d",
    bgColor: "#1C1C1C",
    kabaOpacity: 0.8,
    currentKabaOpacity: 0.8,
    kabaColor1: "#894f2d",
    kabaColor2: "#513e3a",
    followMouse: true,
    mouseSpeed: 0.2,
    kabaZoom: 0.53,
    vaporType: 1,
    vaporVignette: false,
    vaporIntensity: 0.6,
    vaporAmount: 0.1,
    vaporSpeed: 0.003,
    vaporScale: 0.13,
    grungify: false,
    grungifyIntensity: 0.9,
    grungifyScale: 0.5,
    grungifySpeed: 0.2,
    grungifyLineIntensity: 0.01,
    grungifyLines: 100,
    glitch: false,
    gltichType: 3,
    glitchSep: Math.random() / 30,
    glitchAngle: $f5a7455c73851c46$var$randomFloat(-Math.PI, Math.PI),
    glitchSeed: Math.random(),
    glitchSeedX: 0.0,
    glitchSeedY: 0.0,
    glitchDistortX: 0.1,
    glitchDistortY: 0.1,
    glitchColumns: 0.1,
    frameRate: 24
};
const $f5a7455c73851c46$var$MOUSE_POS = {
    currentX: 0,
    currentY: 0,
    targetX: 0,
    targetY: 0
};
const $f5a7455c73851c46$var$tpContainer = document.querySelector(".pane");
const $f5a7455c73851c46$var$pane = new (0, $19eaca503e9293fb$exports.Pane)({
    title: "Kaba Pattern Tweaks",
    container: $f5a7455c73851c46$var$tpContainer
});
const $f5a7455c73851c46$var$btnHide = $f5a7455c73851c46$var$pane.addButton({
    title: "exit tweak mode"
});
$f5a7455c73851c46$var$btnHide.on("click", (ev)=>{
    $f5a7455c73851c46$var$pHidden = (0, $9jC0R.phidden);
    document.querySelector(".pane").style.display = $f5a7455c73851c46$var$pHidden ? "block" : "none";
    document.querySelector("nav").style.display = !$f5a7455c73851c46$var$pHidden ? "flex" : "none";
    document.querySelector("#welcome").style.display = !$f5a7455c73851c46$var$pHidden ? "block" : "none";
    document.querySelector("#who-we-are").style.display = !$f5a7455c73851c46$var$pHidden ? "flex" : "none";
    document.querySelector("#contact").style.display = !$f5a7455c73851c46$var$pHidden ? "grid" : "none";
    document.querySelector("#request").style.display = !$f5a7455c73851c46$var$pHidden ? "grid" : "none";
    document.querySelector("footer").style.display = !$f5a7455c73851c46$var$pHidden ? "flex" : "none";
    $f5a7455c73851c46$var$pHidden = !(0, $9jC0R.phidden);
});
let $f5a7455c73851c46$var$folder = $f5a7455c73851c46$var$pane.addFolder({
    title: "Basics"
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "starfieldColor", {
    label: "starfield"
}).on("change", ()=>{
    for(let i = 0; i < $f5a7455c73851c46$var$NUM_STARS; i++){
        $f5a7455c73851c46$var$particlesMaterials[i] = new $d5b85d29c0b78636$export$a178c45366ce5d6b({
            color: $f5a7455c73851c46$var$PARAMS.starfieldColor,
            sizeAttenuation: true,
            map: $f5a7455c73851c46$var$stars[i],
            alphaTest: 0.5,
            transparent: true,
            size: 0.035
        });
        $f5a7455c73851c46$var$particles[i].material = $f5a7455c73851c46$var$particlesMaterials[i];
    }
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "bgColor", {
    label: "background"
}).on("change", ()=>{
    $f5a7455c73851c46$var$renderer.setClearColor(new $d5b85d29c0b78636$export$892596cec99bc70e($f5a7455c73851c46$var$PARAMS.bgColor));
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "kabaZoom", {
    label: "zoom",
    min: 0.01,
    max: 1,
    step: 0.01
}).on("change", ()=>{
    $f5a7455c73851c46$var$renderImageTexture();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "kabaOpacity", {
    label: "opacity",
    min: 0,
    max: 1,
    step: 0.01
}).on("change", ()=>{
    $f5a7455c73851c46$var$PARAMS.currentKabaOpacity = $f5a7455c73851c46$var$PARAMS.kabaOpacity;
    $f5a7455c73851c46$var$textureMaterial.uniforms.uOpacity.value = $f5a7455c73851c46$var$mapVapeOpacity();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uOpacity.value = $f5a7455c73851c46$var$mapVapeOpacity();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "kabaColor1", {
    label: "top"
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uColor1.value = new $d5b85d29c0b78636$export$892596cec99bc70e($f5a7455c73851c46$var$PARAMS.kabaColor1);
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "kabaColor2", {
    label: "bottom"
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uColor2.value = new $d5b85d29c0b78636$export$892596cec99bc70e($f5a7455c73851c46$var$PARAMS.kabaColor2);
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "followMouse", {
    label: "mouse"
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "mouseSpeed", {
    label: "amount",
    min: 0.01,
    max: 1,
    step: 0.01
});
$f5a7455c73851c46$var$folder = $f5a7455c73851c46$var$pane.addFolder({
    title: "Vapor"
});
const $f5a7455c73851c46$var$vBtn = $f5a7455c73851c46$var$folder.addButton({
    title: "randomize!",
    label: "vapor"
});
$f5a7455c73851c46$var$vBtn.on("click", ()=>{
    $f5a7455c73851c46$var$PARAMS.vaporType = $f5a7455c73851c46$var$randomInt(0, 6);
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNType.value = $f5a7455c73851c46$var$PARAMS.vaporType;
    $f5a7455c73851c46$var$PARAMS.vaporIntensity = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseIntensity.value = $f5a7455c73851c46$var$mapVapeIntensity();
    $f5a7455c73851c46$var$PARAMS.vaporVignette = Math.random() < 0.5;
    $f5a7455c73851c46$var$fxMaterial.uniforms.uVignette.value = $f5a7455c73851c46$var$PARAMS.vaporVignette ? 1 : 0;
    $f5a7455c73851c46$var$PARAMS.vaporAmount = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoise.value = $f5a7455c73851c46$var$mapVapeAmount();
    $f5a7455c73851c46$var$PARAMS.vaporScale = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseScale.value = $f5a7455c73851c46$var$mapVapeScale();
    $f5a7455c73851c46$var$PARAMS.vaporSpeed = Math.random() / 25;
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseSpeed.value = $f5a7455c73851c46$var$mapVapeSpeed();
    $f5a7455c73851c46$var$pane.refresh();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "vaporType", {
    label: "type",
    options: {
        simplex: 0,
        voronoi: 1,
        "vorn\xfc_1": 2,
        "vorn\xfc_2": 3,
        "vorn\xfc_3": 4
    }
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNType.value = $f5a7455c73851c46$var$PARAMS.vaporType;
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoise.value = $f5a7455c73851c46$var$mapVapeAmount();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseScale.value = $f5a7455c73851c46$var$mapVapeScale();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "vaporVignette", {
    label: "vignette"
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uVignette.value = $f5a7455c73851c46$var$PARAMS.vaporVignette ? 1 : 0;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "vaporAmount", {
    label: "amount",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoise.value = $f5a7455c73851c46$var$mapVapeAmount();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "vaporIntensity", {
    label: "intensity",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseIntensity.value = $f5a7455c73851c46$var$mapVapeIntensity();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "vaporScale", {
    label: "scale",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseScale.value = $f5a7455c73851c46$var$mapVapeScale();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "vaporSpeed", {
    label: "speed",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseSpeed.value = $f5a7455c73851c46$var$mapVapeSpeed();
});
$f5a7455c73851c46$var$folder = $f5a7455c73851c46$var$pane.addFolder({
    title: "Glitch"
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitch", {
    label: "glitch"
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGlitch.value = $f5a7455c73851c46$var$PARAMS.glitch ? 1.0 : 0.0;
});
const $f5a7455c73851c46$var$dbtn = $f5a7455c73851c46$var$folder.addButton({
    title: "randomize!",
    label: "glitch"
});
$f5a7455c73851c46$var$dbtn.on("click", ()=>{
    $f5a7455c73851c46$var$PARAMS.gltichType = $f5a7455c73851c46$var$randomInt(0, 3);
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGType.value = $f5a7455c73851c46$var$PARAMS.gltichType;
    $f5a7455c73851c46$var$PARAMS.glitchSep = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGAmount.value = $f5a7455c73851c46$var$PARAMS.glitchSep / 50;
    $f5a7455c73851c46$var$PARAMS.glitchAngle = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGAngle.value = $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.glitchAngle, 0, 1, -Math.PI, Math.PI);
    $f5a7455c73851c46$var$PARAMS.glitchSeed = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGSeed.value = $f5a7455c73851c46$var$PARAMS.glitchSeed;
    $f5a7455c73851c46$var$PARAMS.glitchSeedX = $f5a7455c73851c46$var$remap(Math.random(), 0, 1, -1, 1);
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGSeedX.value = $f5a7455c73851c46$var$PARAMS.glitchSeedX;
    $f5a7455c73851c46$var$PARAMS.glitchSeedY = $f5a7455c73851c46$var$remap(Math.random(), 0, 1, -1, 1);
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGSeedY.value = $f5a7455c73851c46$var$PARAMS.glitchSeedY;
    $f5a7455c73851c46$var$PARAMS.glitchDistortX = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGlitchionX.value = $f5a7455c73851c46$var$PARAMS.glitchDistortX;
    $f5a7455c73851c46$var$PARAMS.glitchDistortY = Math.random();
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGlitchionY.value = $f5a7455c73851c46$var$PARAMS.glitchDistortY;
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGColumns.value = $f5a7455c73851c46$var$PARAMS.glitchColumns;
    $f5a7455c73851c46$var$PARAMS.glitchColumns = Math.random();
    $f5a7455c73851c46$var$pane.refresh();
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "gltichType", {
    label: "type",
    options: {
        first: 0,
        second: 1,
        third: 2
    }
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGType.value = $f5a7455c73851c46$var$PARAMS.gltichType;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchSep", {
    label: "sep",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGAmount.value = $f5a7455c73851c46$var$PARAMS.glitchSep / 50;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchAngle", {
    label: "angle",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGAngle.value = $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.glitchAngle, 0, 1, -Math.PI, Math.PI);
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchSeed", {
    label: "seed root",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGSeed.value = $f5a7455c73851c46$var$PARAMS.glitchSeed;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchSeedX", {
    label: "seed x",
    step: 0.01,
    min: -1,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGSeedX.value = $f5a7455c73851c46$var$PARAMS.glitchSeedX;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchSeedY", {
    label: "seed y",
    step: 0.01,
    min: -1,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGSeedY.value = $f5a7455c73851c46$var$PARAMS.glitchSeedY;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchDistortX", {
    label: "x distort",
    step: 0.01,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGlitchionX.value = $f5a7455c73851c46$var$PARAMS.glitchDistortX;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchDistortY", {
    label: "y distort",
    step: 0.01,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGlitchionY.value = $f5a7455c73851c46$var$PARAMS.glitchDistortY;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "glitchColumns", {
    label: "columns",
    step: 0.001,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$fxMaterial.uniforms.uGColumns.value = $f5a7455c73851c46$var$PARAMS.glitchColumns;
});
$f5a7455c73851c46$var$folder = $f5a7455c73851c46$var$pane.addFolder({
    title: "Grunge"
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "grungify", {
    label: "grungify"
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uNoise.value = $f5a7455c73851c46$var$PARAMS.grungify ? 1.0 : 0.0;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "grungifyIntensity", {
    label: "intensity",
    step: 0.01,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uNoiseIntensity.value = $f5a7455c73851c46$var$PARAMS.grungifyIntensity;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "grungifyScale", {
    label: "scale",
    step: 0.01,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uNoiseScale.value = $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.grungifyScale, 0, 1, 0.01, 20);
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "grungifySpeed", {
    label: "speed",
    step: 0.01,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uNoiseSpeed.value = $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.grungifySpeed, 0, 1, 0, 10);
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "grungifyLines", {
    label: "lines",
    step: 1,
    min: 0,
    max: 4096
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uLines.value = $f5a7455c73851c46$var$PARAMS.grungifyLines;
});
$f5a7455c73851c46$var$folder.addInput($f5a7455c73851c46$var$PARAMS, "grungifyLineIntensity", {
    label: "linetensity",
    step: 0.01,
    min: 0,
    max: 1
}).on("change", ()=>{
    $f5a7455c73851c46$var$textureMaterial.uniforms.uLineIntensity.value = $f5a7455c73851c46$var$PARAMS.grungifyLineIntensity;
});
/**
 * Base
 */ $d5b85d29c0b78636$export$5e6fd513f44698c.enabled = false;
const $f5a7455c73851c46$var$canvas = document.querySelector(".webgl");
const $f5a7455c73851c46$var$scene = new $d5b85d29c0b78636$export$38af1803e3442a7f();
const $f5a7455c73851c46$var$directionalLight = new $d5b85d29c0b78636$export$3fea33cc9972c868("#ffffff", 1);
$f5a7455c73851c46$var$directionalLight.position.set(1, 1, 0);
$f5a7455c73851c46$var$scene.add($f5a7455c73851c46$var$directionalLight);
/**
 * Kaba Vapor
 */ // Image Texture
const $f5a7455c73851c46$var$textureCanvas = document.createElement("canvas");
$f5a7455c73851c46$var$textureCanvas.width = $f5a7455c73851c46$var$SIZES.width;
$f5a7455c73851c46$var$textureCanvas.height = $f5a7455c73851c46$var$SIZES.height;
const $f5a7455c73851c46$var$ctx = $f5a7455c73851c46$var$textureCanvas.getContext("2d");
let $f5a7455c73851c46$var$textureImg = new Image();
$f5a7455c73851c46$var$textureImg.onload = function() {
    $f5a7455c73851c46$var$scene.add($f5a7455c73851c46$var$textureMesh);
    $f5a7455c73851c46$var$renderImageTexture();
};
var $dfb1a86b61f16401$exports = {};

$dfb1a86b61f16401$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "hippo.547697ff.png";


const $f5a7455c73851c46$var$loadImage = ()=>{
    $f5a7455c73851c46$var$textureImg.src = new URL($dfb1a86b61f16401$exports);
// textureImg.src = new URL("./kaba-main-preview.png", import.meta.url);
};
// Shader Image
const $f5a7455c73851c46$var$texVertexShader = /*glsl*/ `
    varying vec2 vUv;

    void main () {
        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
        vUv = uv;
    }
`;
const $f5a7455c73851c46$var$texFragmentShader = /*glsl*/ `
    uniform sampler2D sampler;
    uniform float uTime;
    uniform float uNoise;
    uniform float uNoiseIntensity;
    uniform float uNoiseSpeed;
    uniform float uNoiseScale;
    uniform float uLineIntensity;
    uniform float uLines;
    uniform vec3 uColor1;
    uniform vec3 uColor2;
    uniform float uOpacity;
    varying vec2 vUv;

    //	Simplex 3D Noise 
    //	by Ian McEwan, Ashima Arts
    //
    vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x, 289.0);}
    vec4 taylorInvSqrt(vec4 r){return 1.79284291400159 - 0.85373472095314 * r;}

    float snoise(vec3 v){ 
        const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
        const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);

        // First corner
        vec3 i  = floor(v + dot(v, C.yyy) );
        vec3 x0 =   v - i + dot(i, C.xxx) ;

        // Other corners
        vec3 g = step(x0.yzx, x0.xyz);
        vec3 l = 1.0 - g;
        vec3 i1 = min( g.xyz, l.zxy );
        vec3 i2 = max( g.xyz, l.zxy );

        //  x0 = x0 - 0. + 0.0 * C 
        vec3 x1 = x0 - i1 + 1.0 * C.xxx;
        vec3 x2 = x0 - i2 + 2.0 * C.xxx;
        vec3 x3 = x0 - 1. + 3.0 * C.xxx;

        // Permutations
        i = mod(i, 289.0 ); 
        vec4 p = permute( permute( permute( 
                    i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
                + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
                + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));

        // Gradients
        // ( N*N points uniformly over a square, mapped onto an octahedron.)
        float n_ = 1.0/7.0; // N=7
        vec3  ns = n_ * D.wyz - D.xzx;

        vec4 j = p - 49.0 * floor(p * ns.z *ns.z);  //  mod(p,N*N)

        vec4 x_ = floor(j * ns.z);
        vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)

        vec4 x = x_ *ns.x + ns.yyyy;
        vec4 y = y_ *ns.x + ns.yyyy;
        vec4 h = 1.0 - abs(x) - abs(y);

        vec4 b0 = vec4( x.xy, y.xy );
        vec4 b1 = vec4( x.zw, y.zw );

        vec4 s0 = floor(b0)*2.0 + 1.0;
        vec4 s1 = floor(b1)*2.0 + 1.0;
        vec4 sh = -step(h, vec4(0.0));

        vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
        vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;

        vec3 p0 = vec3(a0.xy,h.x);
        vec3 p1 = vec3(a0.zw,h.y);
        vec3 p2 = vec3(a1.xy,h.z);
        vec3 p3 = vec3(a1.zw,h.w);

        //Normalise gradients
        vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
        p0 *= norm.x;
        p1 *= norm.y;
        p2 *= norm.z;
        p3 *= norm.w;

        // Mix final noise value
        vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
        m = m * m;
        return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
                                        dot(p2,x2), dot(p3,x3) ) );
    }

    vec3 adjustSaturation(vec3 color, float value) {
        // https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
        const vec3 luminosityFactor = vec3(0.2126, 0.7152, 0.0722);
        vec3 grayscale = vec3(dot(color, luminosityFactor));

        return mix(grayscale, color, 1.0 + value);
    }

    void main () {
        vec4 texColor = texture2D(sampler, vUv);
        if (texColor.a < 0.9) {
            discard;
        } else {
            vec3 color = vec3(mix(uColor1,uColor2,1.-vUv.y));
            if(uNoise == 1.){
                // make some noise
                vec2 uv = gl_FragCoord.xy;
                uv /= uNoiseScale;
                float n = snoise(vec3(uv, uTime * uNoiseSpeed));
                // add noise
                vec3 colorNoise = vec3(n * 0.5 + 0.5);
                color *= mix(colorNoise * uNoiseIntensity * 2., color, 1. - uNoiseIntensity);
                // get us a sine and cosine
                vec2 sc = vec2( sin( vUv.y * uLines ), cos( vUv.y * uLines ) );
                // add scanlines
                color += color * vec3( sc.x, sc.y, sc.x ) * uLineIntensity;
            }
            color = adjustSaturation(color, uOpacity*0.5);
            gl_FragColor =  vec4(color, uOpacity);
        }
    }
`;
const $f5a7455c73851c46$var$textureGeometry = new $d5b85d29c0b78636$export$967d831af31f69ce($f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
const $f5a7455c73851c46$var$textureMaterial = new $d5b85d29c0b78636$export$83c7d75d550a8b0d({
    uniforms: {
        sampler: {
            value: null
        },
        uTime: {
            value: 0
        },
        uNoise: {
            value: $f5a7455c73851c46$var$PARAMS.grungify ? 1.0 : 0.0
        },
        uNoiseIntensity: {
            value: $f5a7455c73851c46$var$PARAMS.grungifyIntensity
        },
        uNoiseScale: {
            value: $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.grungifyScale, 0, 1, 0.01, 20)
        },
        uNoiseSpeed: {
            value: $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.grungifySpeed, 0, 1, 0, 10)
        },
        uLineIntensity: {
            value: $f5a7455c73851c46$var$PARAMS.grungifyLineIntensity
        },
        uLines: {
            value: $f5a7455c73851c46$var$PARAMS.grungifyLines
        },
        uColor1: {
            value: new $d5b85d29c0b78636$export$892596cec99bc70e($f5a7455c73851c46$var$PARAMS.kabaColor1)
        },
        uColor2: {
            value: new $d5b85d29c0b78636$export$892596cec99bc70e($f5a7455c73851c46$var$PARAMS.kabaColor2)
        },
        uOpacity: {
            value: $f5a7455c73851c46$var$mapVapeOpacity()
        }
    },
    vertexShader: $f5a7455c73851c46$var$texVertexShader,
    fragmentShader: $f5a7455c73851c46$var$texFragmentShader,
    transparent: true
});
const $f5a7455c73851c46$var$textureMesh = new $d5b85d29c0b78636$export$e176487c05830cc5($f5a7455c73851c46$var$textureGeometry, $f5a7455c73851c46$var$textureMaterial);
$f5a7455c73851c46$var$textureMesh.position.z = -1300;
// Shader Vapor
const $f5a7455c73851c46$var$generateHeightmap = ()=>{
    const dt_size = 64;
    const data_arr = new Float32Array(dt_size * dt_size);
    const length = dt_size * dt_size;
    for(let i = 0; i < length; i++){
        const val = $f5a7455c73851c46$var$randomFloat(0, 1);
        data_arr[i] = val;
    }
    const texture = new $d5b85d29c0b78636$export$b691f601014eabe1(data_arr, dt_size, dt_size, $d5b85d29c0b78636$export$4e041a7967d15c4b, $d5b85d29c0b78636$export$f6d331659b644596);
    texture.needsUpdate = true;
    return texture;
};
const $f5a7455c73851c46$var$fxVertexShader = /*glsl*/ `
    varying vec2 vUv;

    void main () {
        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
        vUv = uv;
    }
`;
const $f5a7455c73851c46$var$fxFragmentShader = /*glsl*/ `
    uniform sampler2D sampler;
    uniform int uGlitch;
    uniform int uNType;
    uniform int uGType;
    uniform sampler2D uGDisplace;
    uniform float uGAmount;
    uniform float uGAngle;
    uniform float uGSeed;
    uniform float uGSeedX;
    uniform float uGSeedY;
    uniform float uGlitchionX;
    uniform float uGlitchionY;
    uniform float uGColumns;
    uniform float uTime;
    uniform vec2 uMouse;
    uniform float uNoiseIntensity;
    uniform int uVignette;
    uniform float uNoise;
    uniform float uNoiseSpeed;
    uniform float uNoiseScale;
    uniform float uOpacity;
    varying vec2 vUv;

    #define M_PI 3.14159265358979323846

    float rand(vec2 n) { 
        return fract(sin(dot(n, vec2(12.9898, 4.1414))) * 43758.5453);
    }

    const mat2 myt = mat2(.12121212, .13131313, -.13131313, .12121212);
    const vec2 mys = vec2(1e4, 1e6);

    vec2 rhash(vec2 uv) {
    uv *= myt;
    uv *= mys;
    return fract(fract(uv / mys) * uv);
    }

    vec3 hash(vec3 p) {
    return fract(
        sin(vec3(dot(p, vec3(1.0, 57.0, 113.0)), dot(p, vec3(57.0, 113.0, 1.0)),
                dot(p, vec3(113.0, 1.0, 57.0)))) *
        43758.5453);
    }

    vec3 voronoi3d(const in vec3 x, const in int m) {
    vec3 p = floor(x);
    vec3 f = fract(x);

    float id = 0.0;
    vec2 res = vec2(100.0);
    for (int k = -1; k <= 1; k++) {
        for (int j = -1; j <= 1; j++) {
        for (int i = -1; i <= 1; i++) {
            vec3 b = vec3(float(i), float(j), float(k));
            vec3 r = vec3(b) - f + hash(p + b);
            float d = dot(r, r);

            float cond = max(sign(res.x - d), 0.0);
            float nCond = 1.0 - cond;

            float cond2 = nCond * max(sign(res.y - d), 0.0);
            float nCond2 = 1.0 - cond2;

            id = (dot(p + b, vec3(1.0, 57.0, 113.0)) * cond) + (id * nCond);
            res = vec2(d, res.x) * cond + res * nCond;

            if(m == 1){
                res.y = cond2 * d + nCond2 * res.y;
            }
            else if(m == 2){
                res.y = -cond2 * d + nCond2 * res.y;
            } 
            else if(m == 3){
                res.y = cond2 * d + nCond*-nCond2*-nCond2 * res.y;
            }
            else {
                res.y = cond * d - -nCond2 * res.x;
            }
        }
        }
    }

    return vec3(sqrt(res), abs(id));
    }

    //	Simplex 3D Noise 
    //	by Ian McEwan, Ashima Arts
    //
    vec4 permute(vec4 x){return mod(((x*34.0)+1.0)*x, 289.0);}
    vec4 taylorInvSqrt(vec4 r){return 1.79284291400159 - 0.85373472095314 * r;}

    float snoise(vec3 v){ 
    const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
    const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);

    // First corner
    vec3 i  = floor(v + dot(v, C.yyy) );
    vec3 x0 =   v - i + dot(i, C.xxx) ;

    // Other corners
    vec3 g = step(x0.yzx, x0.xyz);
    vec3 l = 1.0 - g;
    vec3 i1 = min( g.xyz, l.zxy );
    vec3 i2 = max( g.xyz, l.zxy );

    //  x0 = x0 - 0. + 0.0 * C 
    vec3 x1 = x0 - i1 + 1.0 * C.xxx;
    vec3 x2 = x0 - i2 + 2.0 * C.xxx;
    vec3 x3 = x0 - 1. + 3.0 * C.xxx;

    // Permutations
    i = mod(i, 289.0 ); 
    vec4 p = permute( permute( permute( 
                i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
            + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
            + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));

    // Gradients
    // ( N*N points uniformly over a square, mapped onto an octahedron.)
    float n_ = 1.0/7.0; // N=7
    vec3  ns = n_ * D.wyz - D.xzx;

    vec4 j = p - 49.0 * floor(p * ns.z *ns.z);  //  mod(p,N*N)

    vec4 x_ = floor(j * ns.z);
    vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)

    vec4 x = x_ *ns.x + ns.yyyy;
    vec4 y = y_ *ns.x + ns.yyyy;
    vec4 h = 1.0 - abs(x) - abs(y);

    vec4 b0 = vec4( x.xy, y.xy );
    vec4 b1 = vec4( x.zw, y.zw );

    vec4 s0 = floor(b0)*2.0 + 1.0;
    vec4 s1 = floor(b1)*2.0 + 1.0;
    vec4 sh = -step(h, vec4(0.0));

    vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
    vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;

    vec3 p0 = vec3(a0.xy,h.x);
    vec3 p1 = vec3(a0.zw,h.y);
    vec3 p2 = vec3(a1.xy,h.z);
    vec3 p3 = vec3(a1.zw,h.w);

    //Normalise gradients
    vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;

    // Mix final noise value
    vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
    m = m * m;
    return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
                                    dot(p2,x2), dot(p3,x3) ) );
    }

    void main () {
        vec4 t0 = vec4(0);
        float v = (uVignette == 0 ? 0. : distance(vUv,vec2(0.5)));
        if(uNType<1){
            float a = snoise(vec3(vUv * uNoise, uTime * uNoiseSpeed * 0.75)) * uNoiseScale;
            float b = snoise(vec3(vUv * uNoise, uTime * uNoiseSpeed * 0.75)) * uNoiseScale;
            // t0 = texture2D(sampler, vUv - vec2(a, b) + uMouse * 0.005);
            t0 = texture2D(sampler, vUv - vec2(a, b) + uMouse * 0.002);
        }
        else {
            vec3 a = voronoi3d(vec3(vUv * -uNoise, uTime * uNoiseSpeed), uNType) * uNoiseScale;
            vec3 b = -voronoi3d(vec3(vUv * uNoise, -uTime * uNoiseSpeed), uNType) * uNoiseScale;
            t0 = texture2D(sampler, vUv + a.xy + b.xy + uMouse * 0.005);
        }

        if(uGlitch>0) {
            vec2 p = vUv;
            float xs = floor(gl_FragCoord.x / 0.1);
            float ys = floor(gl_FragCoord.y / 0.1);
            //based on staffantans glitch shader for unity https://github.com/staffantan/unityglitch
            float disp = texture2D(uGDisplace, p*uGSeed*uGSeed).r;
            if(p.y<uGlitchionX+uGColumns && p.y>uGlitchionY-uGColumns*uGSeed) {
                if(uGSeedX>0.){
                    p.y = 1. - (p.y + uGlitchionY);
                }
                else {
                    p.y = uGlitchionY;
                }
            }
            if(p.x<uGlitchionY+uGColumns && p.x>uGlitchionY-uGColumns*uGSeed) {
                if(uGSeedY>0.){
                    p.x=uGlitchionX;
                }
                else {
                    p.x = 1. - (p.x + uGlitchionX);
                }
            }
            p.x+=disp*uGSeedX*(uGSeed/0.5);
            p.y+=disp*uGSeedY*(uGSeed/0.5);
            
            //base from RGB shift shader
            vec2 offset = uGAmount * vec2( cos(uGAngle), sin(uGAngle));
            vec4 cr = texture2D(sampler, p + offset);
            vec4 cga = texture2D(sampler, p);
            vec4 cb = texture2D(sampler, p - offset);
            vec4 finalColor = vec4(cr.r, cga.g, cb.b, cga.a);
            
            //add noise
            // vec4 snow = 200.*uGAmount*vec4(rand(vec2(xs * uGSeed,ys * uGSeed*50.))*0.2);
            // finalColor += snow;

            //this is starting to get somewhere
            if(uGType==0){
                gl_FragColor = vec4(t0.xyz - finalColor.xyz, uNoiseIntensity-v);
            }
            else if(uGType==1) {
                gl_FragColor = vec4(finalColor.xyz - t0.xyz, uNoiseIntensity-v);
            }
            else {
                gl_FragColor = vec4((t0.xyz - finalColor.xyz) / length(t0.xyz), uNoiseIntensity-v);
            }
            //this produces kinda alpha
            // gl_FragColor = vec4(t0.xyz * uColorPersist, uAlphaPersist * t0.a);
        }
        else {
            // gl_FragColor = vec4(t0.xyz, pow(uNoiseIntensity * 0.999, uTime));
            gl_FragColor = vec4(t0.xyz, (uNoiseIntensity-v)*uOpacity);
        }
    }
`;
const $f5a7455c73851c46$var$fxScene = new $d5b85d29c0b78636$export$38af1803e3442a7f();
const $f5a7455c73851c46$var$fxGeometry = new $d5b85d29c0b78636$export$967d831af31f69ce($f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
const $f5a7455c73851c46$var$fxMaterial = new $d5b85d29c0b78636$export$83c7d75d550a8b0d({
    vertexShader: $f5a7455c73851c46$var$fxVertexShader,
    fragmentShader: $f5a7455c73851c46$var$fxFragmentShader,
    transparent: true,
    uniforms: {
        sampler: {
            value: null
        },
        uGlitch: {
            value: $f5a7455c73851c46$var$PARAMS.glitch ? 1.0 : 0.0
        },
        uNType: {
            value: $f5a7455c73851c46$var$PARAMS.vaporType
        },
        uGType: {
            value: $f5a7455c73851c46$var$PARAMS.gltichType
        },
        uGDisplace: {
            value: $f5a7455c73851c46$var$generateHeightmap()
        },
        uGAmount: {
            value: $f5a7455c73851c46$var$PARAMS.glitchSep / 50
        },
        uGAngle: {
            value: $f5a7455c73851c46$var$mapGlitchAngle()
        },
        uGSeed: {
            value: $f5a7455c73851c46$var$PARAMS.glitchSeed
        },
        uGSeedX: {
            value: $f5a7455c73851c46$var$PARAMS.glitchSeedX
        },
        uGSeedY: {
            value: $f5a7455c73851c46$var$PARAMS.glitchSeedY
        },
        uGlitchionX: {
            value: $f5a7455c73851c46$var$PARAMS.glitchDistortX
        },
        uGlitchionY: {
            value: $f5a7455c73851c46$var$PARAMS.glitchDistortY
        },
        uGColumns: {
            value: $f5a7455c73851c46$var$PARAMS.glitchColumns
        },
        uTime: {
            value: 0
        },
        uMouse: {
            value: new $d5b85d29c0b78636$export$c977b3e384af9ae1(-1, -1)
        },
        uNoiseIntensity: {
            value: $f5a7455c73851c46$var$mapVapeIntensity()
        },
        uVignette: {
            value: $f5a7455c73851c46$var$PARAMS.vaporVignette ? 1 : 0
        },
        uNoise: {
            value: $f5a7455c73851c46$var$mapVapeAmount()
        },
        uNoiseSpeed: {
            value: $f5a7455c73851c46$var$mapVapeSpeed()
        },
        uNoiseScale: {
            value: $f5a7455c73851c46$var$mapVapeScale()
        },
        uOpacity: {
            value: $f5a7455c73851c46$var$mapVapeOpacity()
        }
    }
});
const $f5a7455c73851c46$var$fxMesh = new $d5b85d29c0b78636$export$e176487c05830cc5($f5a7455c73851c46$var$fxGeometry, $f5a7455c73851c46$var$fxMaterial);
$f5a7455c73851c46$var$fxScene.add($f5a7455c73851c46$var$fxMesh);
/**
 * Starfield
 */ let $f5a7455c73851c46$var$stars = [];
const $f5a7455c73851c46$var$loader = new $d5b85d29c0b78636$export$fd1bfc71f64c538c();
var $68bcb9e19cbfbdbf$exports = {};

$68bcb9e19cbfbdbf$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "star1.0e395a85.png";


var $ba4afe866addc2a9$exports = {};

$ba4afe866addc2a9$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "star2.dad2fd56.png";


var $14c2037c057b6982$exports = {};

$14c2037c057b6982$exports = (parcelRequire("cHmwT")).getBundleURL('jU3hC') + "star3.63fbb0ab.png";


const $f5a7455c73851c46$var$loadStars = ()=>{
    $f5a7455c73851c46$var$loader.load(new URL($68bcb9e19cbfbdbf$exports), function(texture) {
        $f5a7455c73851c46$var$stars.push(texture);
        $f5a7455c73851c46$var$loader.load(new URL($ba4afe866addc2a9$exports), function(texture) {
            $f5a7455c73851c46$var$stars.push(texture);
            $f5a7455c73851c46$var$loader.load(new URL($14c2037c057b6982$exports), function(texture) {
                $f5a7455c73851c46$var$stars.push(texture);
                $f5a7455c73851c46$var$loadParticles();
            });
        });
    });
};
// Geometry
const $f5a7455c73851c46$var$NUM_STARS = 3;
const $f5a7455c73851c46$var$SCREEN_HEIGHT = 3;
const $f5a7455c73851c46$var$P_SPREAD = 5;
const $f5a7455c73851c46$var$particlesCount = 500;
const $f5a7455c73851c46$var$particlesMaterials = [];
const $f5a7455c73851c46$var$particles = [];
const $f5a7455c73851c46$var$particleGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
const $f5a7455c73851c46$var$loadParticles = ()=>{
    for(let j = 0; j < $f5a7455c73851c46$var$NUM_STARS; j++){
        const positions = new Float32Array($f5a7455c73851c46$var$particlesCount * 3);
        for(let i = 0; i < $f5a7455c73851c46$var$particlesCount; i++){
            positions[i * 3 + 0] = (Math.random() - 0.5) * $f5a7455c73851c46$var$P_SPREAD * $f5a7455c73851c46$var$SCREEN_HEIGHT;
            positions[i * 3 + 1] = -$f5a7455c73851c46$var$remap(Math.random(), 0, 1, -$f5a7455c73851c46$var$P_SPREAD * 0.25, $f5a7455c73851c46$var$P_SPREAD * $f5a7455c73851c46$var$SCREEN_HEIGHT);
            positions[i * 3 + 2] = Math.random() * $f5a7455c73851c46$var$P_SPREAD;
        }
        const particlesGeometry = new $d5b85d29c0b78636$export$b7be63a67df8959();
        particlesGeometry.setAttribute("position", new $d5b85d29c0b78636$export$8dea267bd6bde117(positions, 3));
        // Material
        $f5a7455c73851c46$var$particlesMaterials[j] = new $d5b85d29c0b78636$export$a178c45366ce5d6b({
            color: $f5a7455c73851c46$var$PARAMS.starfieldColor,
            sizeAttenuation: true,
            map: $f5a7455c73851c46$var$stars[j],
            alphaTest: 0.5,
            transparent: true,
            size: 0.035
        });
        $f5a7455c73851c46$var$particlesMaterials[j].opacity = 0.7;
        // Points
        $f5a7455c73851c46$var$particles.push(new $d5b85d29c0b78636$export$1c787534cb11aa3e(particlesGeometry, $f5a7455c73851c46$var$particlesMaterials[j]));
        $f5a7455c73851c46$var$particleGroup.add($f5a7455c73851c46$var$particles[j]);
        $f5a7455c73851c46$var$scene.add($f5a7455c73851c46$var$particleGroup);
    }
};
window.addEventListener("resize", ()=>{
    $f5a7455c73851c46$var$handleMobileCheck();
    $f5a7455c73851c46$var$SIZES.width = window.innerWidth;
    $f5a7455c73851c46$var$SIZES.height = window.innerHeight;
    $f5a7455c73851c46$var$camera.aspect = $f5a7455c73851c46$var$SIZES.width / $f5a7455c73851c46$var$SIZES.height;
    $f5a7455c73851c46$var$camera.updateProjectionMatrix();
    $f5a7455c73851c46$var$renderer.setSize($f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
    $f5a7455c73851c46$var$renderBufferA.setSize($f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
    $f5a7455c73851c46$var$renderBufferB.setSize($f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
    $f5a7455c73851c46$var$renderImageTexture();
    $f5a7455c73851c46$var$fitObjects();
});
const $f5a7455c73851c46$var$fitObjects = ()=>{
    let vFOV = $d5b85d29c0b78636$export$6a7ef315a0d1ef07.degToRad($f5a7455c73851c46$var$camera.fov); // convert vertical fov to radians
    let vH = 2 * Math.tan(vFOV / 2) * 6; // visible height
    let vW = vH * $f5a7455c73851c46$var$camera.aspect; // visible width
// group.scale.y = vH + 8;
// group.scale.x = vW + 2;
// group.position.x = -(vW + 2) * 0.39;
// group.position.y = vH * 0.5;
};
/**
 * Scroll
 */ let $f5a7455c73851c46$var$scrollY = 0;
let $f5a7455c73851c46$var$progress = 0;
let $f5a7455c73851c46$var$currentSection = 0;
const $f5a7455c73851c46$var$FX_CUTOFF = 0.5;
window.addEventListener("load", ()=>{
    $f5a7455c73851c46$var$handleMobileCheck();
    $f5a7455c73851c46$var$camera.position.y = -($f5a7455c73851c46$var$scrollY / $f5a7455c73851c46$var$SIZES.height * $f5a7455c73851c46$var$SCREEN_HEIGHT) + $f5a7455c73851c46$var$SCREEN_HEIGHT;
});
document.body.addEventListener("scroll", (e)=>{
    $f5a7455c73851c46$var$handleScroll(e);
});
const $f5a7455c73851c46$var$handleScroll = (e)=>{
    $f5a7455c73851c46$var$scrollY = Math.min(Math.max(0, e.target.scrollTop), e.target.scrollHeight);
    $f5a7455c73851c46$var$progress = $f5a7455c73851c46$var$scrollY / window.innerHeight % 1;
    const newSection = Math.floor($f5a7455c73851c46$var$scrollY / $f5a7455c73851c46$var$SIZES.height);
    if (newSection != $f5a7455c73851c46$var$currentSection) $f5a7455c73851c46$var$currentSection = newSection;
    (0, $177d6097cd356643$export$2417ba97adc3c044)($f5a7455c73851c46$var$findOutClicked ? $f5a7455c73851c46$var$currentSection : $f5a7455c73851c46$var$currentSection - 1, $f5a7455c73851c46$var$progress);
    if ($f5a7455c73851c46$var$currentSection == 0) {
        if ($f5a7455c73851c46$var$previousTime > 0.3 && !$f5a7455c73851c46$var$foundOut) $f5a7455c73851c46$var$findOut();
        gsap.to($f5a7455c73851c46$var$PARAMS, {
            currentKabaOpacity: $f5a7455c73851c46$var$PARAMS.kabaOpacity * (1 - $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$progress, 0, $f5a7455c73851c46$var$FX_CUTOFF, 0, 1)),
            duration: 0.1,
            onUpdate: ()=>{
                if ($f5a7455c73851c46$var$currentSection > 0) $f5a7455c73851c46$var$PARAMS.currentKabaOpacity = 0;
                $f5a7455c73851c46$var$textureMaterial.uniforms.uOpacity.value = $f5a7455c73851c46$var$mapVapeOpacity();
                $f5a7455c73851c46$var$fxMaterial.uniforms.uOpacity.value = $f5a7455c73851c46$var$mapVapeOpacity();
            }
        });
    }
    // Animate camera
    gsap.to($f5a7455c73851c46$var$camera.position, {
        y: -($f5a7455c73851c46$var$scrollY / $f5a7455c73851c46$var$SIZES.height * $f5a7455c73851c46$var$SCREEN_HEIGHT) + $f5a7455c73851c46$var$SCREEN_HEIGHT,
        duration: 0.35,
        ease: "power2.inout"
    });
    gsap.to((0, $177d6097cd356643$export$16c5ba6a7cb25d77).position, {
        y: -($f5a7455c73851c46$var$scrollY / $f5a7455c73851c46$var$SIZES.height * $f5a7455c73851c46$var$SCREEN_HEIGHT) + $f5a7455c73851c46$var$SCREEN_HEIGHT,
        duration: 0.35,
        ease: "power2.inout"
    });
};
let $f5a7455c73851c46$var$isMobile = false;
const $f5a7455c73851c46$var$handleMobileCheck = ()=>{
    $f5a7455c73851c46$var$isMobile = window.innerWidth <= 900; //kludge to account for mobile browsers that hide/show their chrome on scroll
};
/**
 * Cursor
 */ const $f5a7455c73851c46$var$cursor = {};
$f5a7455c73851c46$var$cursor.x = 0;
$f5a7455c73851c46$var$cursor.y = 0;
window.addEventListener("pointermove", (e)=>{
    if (!$f5a7455c73851c46$var$PARAMS.followMouse) return;
    $f5a7455c73851c46$var$cursor.x = e.clientX / $f5a7455c73851c46$var$SIZES.width - 0.5;
    $f5a7455c73851c46$var$cursor.y = e.clientY / $f5a7455c73851c46$var$SIZES.height - 0.5;
    const x = e.pageX / $f5a7455c73851c46$var$SIZES.width * 2 - 1;
    const y = (1 - e.pageY / $f5a7455c73851c46$var$SIZES.height) * 2 - 1;
    $f5a7455c73851c46$var$MOUSE_POS.targetX = x;
    $f5a7455c73851c46$var$MOUSE_POS.targetY = y;
    // HIPPO
    gsap.to($f5a7455c73851c46$var$textureMesh.rotation, {
        y: -Math.PI * 0.25 * $f5a7455c73851c46$var$PARAMS.mouseSpeed * x,
        ease: "power2.inout",
        duration: 0.75
    });
    gsap.to($f5a7455c73851c46$var$textureMesh.rotation, {
        x: Math.PI * 0.25 * $f5a7455c73851c46$var$PARAMS.mouseSpeed * y,
        ease: "power2.inout",
        duration: 0.75
    });
});
let $f5a7455c73851c46$var$foundOut = false;
let $f5a7455c73851c46$var$findOutClicked = false;
document.querySelector("#btn-find-out").addEventListener("click", ()=>{
    $f5a7455c73851c46$var$findOutClicked = true;
    $f5a7455c73851c46$var$findOut();
});
document.querySelector("#btn-find-out-two").addEventListener("click", (e)=>{
    console.log(e);
    alert(e);
});
const $f5a7455c73851c46$var$findOut = ()=>{
    $f5a7455c73851c46$var$foundOut = true;
    const DUR = 0.65;
    const z = $f5a7455c73851c46$var$remap(Math.random(), 0, 1, -500, -200);
    const y = $f5a7455c73851c46$var$remap(Math.random(), 0, 1, -200, 200);
    gsap.to($f5a7455c73851c46$var$textureMesh.position, {
        z: z,
        duration: DUR,
        ease: "power1.out"
    });
    gsap.to($f5a7455c73851c46$var$textureMesh.position, {
        y: y,
        duration: DUR,
        ease: "power1.out"
    });
    // vaporIntensity: 0.4,
    // vaporAmount: 0.2,
    // vaporSpeed: 0.004,
    // vaporScale: 0.1,
    gsap.to($f5a7455c73851c46$var$PARAMS, {
        vaporIntensity: 0.6,
        duration: DUR,
        onUpdate: ()=>{
            $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseIntensity.value = $f5a7455c73851c46$var$mapVapeIntensity();
        }
    });
    gsap.to($f5a7455c73851c46$var$PARAMS, {
        vaporAmount: 0.075,
        duration: DUR,
        onUpdate: ()=>{
            $f5a7455c73851c46$var$fxMaterial.uniforms.uNoise.value = $f5a7455c73851c46$var$mapVapeAmount();
        }
    });
    gsap.to($f5a7455c73851c46$var$PARAMS, {
        vaporSpeed: 0.002,
        duration: DUR,
        onUpdate: ()=>{
            $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseSpeed.value = $f5a7455c73851c46$var$mapVapeSpeed();
        }
    });
    gsap.to($f5a7455c73851c46$var$PARAMS, {
        vaporScale: 0.9,
        duration: DUR,
        onUpdate: ()=>{
            $f5a7455c73851c46$var$fxMaterial.uniforms.uNoiseScale.value = $f5a7455c73851c46$var$mapVapeScale();
        }
    });
    $f5a7455c73851c46$var$PARAMS.kabaOpacity = $f5a7455c73851c46$var$FX_CUTOFF;
    gsap.to($f5a7455c73851c46$var$PARAMS, {
        currentKabaOpacity: $f5a7455c73851c46$var$PARAMS.kabaOpacity,
        duration: DUR,
        onUpdate: ()=>{
            if ($f5a7455c73851c46$var$currentSection > 0) $f5a7455c73851c46$var$PARAMS.currentKabaOpacity = 0;
            $f5a7455c73851c46$var$textureMaterial.uniforms.uOpacity.value = $f5a7455c73851c46$var$mapVapeOpacity();
            $f5a7455c73851c46$var$fxMaterial.uniforms.uOpacity.value = $f5a7455c73851c46$var$mapVapeOpacity();
        }
    });
};
/**
 * Camera
 */ // Group
const $f5a7455c73851c46$var$cameraGroup = new $d5b85d29c0b78636$export$eb2fcfdbd7ba97d4();
$f5a7455c73851c46$var$scene.add($f5a7455c73851c46$var$cameraGroup);
// Base camera
const $f5a7455c73851c46$var$fxCam = new $d5b85d29c0b78636$export$9ebf355ee4ed261b(-$f5a7455c73851c46$var$SIZES.width * 0.5, $f5a7455c73851c46$var$SIZES.width * 0.5, $f5a7455c73851c46$var$SIZES.height * 0.5, -$f5a7455c73851c46$var$SIZES.height * 0.5, 0.1, $f5a7455c73851c46$var$P_SPREAD * 2);
$f5a7455c73851c46$var$fxCam.position.z = $f5a7455c73851c46$var$P_SPREAD;
$f5a7455c73851c46$var$fxCam.aspect = $f5a7455c73851c46$var$SIZES.width / $f5a7455c73851c46$var$SIZES.height;
const $f5a7455c73851c46$var$camera = new $d5b85d29c0b78636$export$74e4ae24825f68d7(35, $f5a7455c73851c46$var$SIZES.width / $f5a7455c73851c46$var$SIZES.height, 0.1, 5000);
$f5a7455c73851c46$var$camera.position.z = 6;
$f5a7455c73851c46$var$camera.useQuaternion = true;
$f5a7455c73851c46$var$camera.aspect = $f5a7455c73851c46$var$SIZES.width / $f5a7455c73851c46$var$SIZES.height;
$f5a7455c73851c46$var$cameraGroup.add($f5a7455c73851c46$var$camera);
/**
 * Renderer
 */ // const renderer = new THREE.WebGPURenderer({
const $f5a7455c73851c46$var$renderer = new $3dd44ec8564e7230$export$f6cc00ef28d7cf97({
    canvas: $f5a7455c73851c46$var$canvas,
    antialias: true,
    alpha: true,
    premultipliedAlpha: false
});
// renderer.outputColorSpace = THREE.sRGBEncoding;
$f5a7455c73851c46$var$renderer.setSize($f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
$f5a7455c73851c46$var$renderer.setPixelRatio($f5a7455c73851c46$var$PIXEL_RATIO);
// renderer.setClearColor(new THREE.Color(PARAMS.bgColor));
// renderer.setClearAlpha(0);
let $f5a7455c73851c46$var$renderBufferA = new $d5b85d29c0b78636$export$3c052beb2e51e23f($f5a7455c73851c46$var$SIZES.width * $f5a7455c73851c46$var$PIXEL_RATIO, $f5a7455c73851c46$var$SIZES.height * $f5a7455c73851c46$var$PIXEL_RATIO, {
    format: $d5b85d29c0b78636$export$3f8bb04b555a363c
});
let $f5a7455c73851c46$var$renderBufferB = new $d5b85d29c0b78636$export$3c052beb2e51e23f($f5a7455c73851c46$var$SIZES.width * $f5a7455c73851c46$var$PIXEL_RATIO, $f5a7455c73851c46$var$SIZES.height * $f5a7455c73851c46$var$PIXEL_RATIO, {
    format: $d5b85d29c0b78636$export$3f8bb04b555a363c
});
/**
 * Animate
 */ const $f5a7455c73851c46$var$clock = new $d5b85d29c0b78636$export$9735c82c4bae3302();
let $f5a7455c73851c46$var$previousTime = 0;
let $f5a7455c73851c46$var$delta = 0;
let $f5a7455c73851c46$var$interval = 1 / $f5a7455c73851c46$var$PARAMS.frameRate;
const $f5a7455c73851c46$var$tick = ()=>{
    $f5a7455c73851c46$var$delta += $f5a7455c73851c46$var$clock.getDelta();
    if ($f5a7455c73851c46$var$delta > $f5a7455c73851c46$var$interval) {
        $f5a7455c73851c46$var$delta = $f5a7455c73851c46$var$delta % $f5a7455c73851c46$var$interval;
        const elapsedTime = $f5a7455c73851c46$var$clock.getElapsedTime();
        const deltaTime = elapsedTime - $f5a7455c73851c46$var$previousTime;
        $f5a7455c73851c46$var$previousTime = elapsedTime;
        const parallaxX = $f5a7455c73851c46$var$cursor.x * 0.05;
        const parallaxY = -$f5a7455c73851c46$var$cursor.y * 0.05;
        $f5a7455c73851c46$var$cameraGroup.position.x += (parallaxX - $f5a7455c73851c46$var$cameraGroup.position.x) * 5 * deltaTime;
        $f5a7455c73851c46$var$cameraGroup.position.y += (parallaxY - $f5a7455c73851c46$var$cameraGroup.position.y) * 5 * deltaTime;
        if ($f5a7455c73851c46$var$PARAMS.followMouse) {
            const mappedSpeed = $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.mouseSpeed, 0, 1, 0, 50);
            const mouseSpeed = deltaTime * mappedSpeed;
            $f5a7455c73851c46$var$MOUSE_POS.currentX += ($f5a7455c73851c46$var$MOUSE_POS.targetX - $f5a7455c73851c46$var$MOUSE_POS.currentX) * mouseSpeed;
            $f5a7455c73851c46$var$MOUSE_POS.currentY += ($f5a7455c73851c46$var$MOUSE_POS.targetY - $f5a7455c73851c46$var$MOUSE_POS.currentY) * mouseSpeed;
            $f5a7455c73851c46$var$fxMaterial.uniforms.uMouse.value.x = $f5a7455c73851c46$var$MOUSE_POS.currentX;
            $f5a7455c73851c46$var$fxMaterial.uniforms.uMouse.value.y = $f5a7455c73851c46$var$MOUSE_POS.currentY;
        }
        $f5a7455c73851c46$var$fxMaterial.uniforms.sampler.value = $f5a7455c73851c46$var$renderBufferB.texture;
        $f5a7455c73851c46$var$fxMaterial.uniforms.uTime.value = elapsedTime;
        if ($f5a7455c73851c46$var$currentSection == 0 && $f5a7455c73851c46$var$progress < $f5a7455c73851c46$var$FX_CUTOFF) {
            $f5a7455c73851c46$var$renderer.autoClearColor = false;
            $f5a7455c73851c46$var$renderer.setRenderTarget($f5a7455c73851c46$var$renderBufferA);
            $f5a7455c73851c46$var$renderer.clearColor();
            $f5a7455c73851c46$var$renderer.render($f5a7455c73851c46$var$fxScene, $f5a7455c73851c46$var$fxCam);
            $f5a7455c73851c46$var$renderer.render($f5a7455c73851c46$var$scene, $f5a7455c73851c46$var$camera);
            $f5a7455c73851c46$var$renderer.setRenderTarget(null);
            $f5a7455c73851c46$var$renderer.render($f5a7455c73851c46$var$fxScene, $f5a7455c73851c46$var$fxCam);
        } else $f5a7455c73851c46$var$renderer.render($f5a7455c73851c46$var$scene, $f5a7455c73851c46$var$camera);
        const temp = $f5a7455c73851c46$var$renderBufferA;
        $f5a7455c73851c46$var$renderBufferA = $f5a7455c73851c46$var$renderBufferB;
        $f5a7455c73851c46$var$renderBufferB = temp;
        if ($f5a7455c73851c46$var$textureMaterial) $f5a7455c73851c46$var$textureMaterial.uniforms.uTime.value = elapsedTime;
    }
    // Call tick again on the next frame
    window.requestAnimationFrame($f5a7455c73851c46$var$tick);
};
$f5a7455c73851c46$var$loadImage();
$f5a7455c73851c46$var$loadStars();
(0, $177d6097cd356643$export$4887ad270a8312d5)($f5a7455c73851c46$var$scene);
$f5a7455c73851c46$var$tick();
$f5a7455c73851c46$var$fitObjects();
const $f5a7455c73851c46$var$navButtons = document.querySelectorAll("#button-who-we-are, #button-contact");
// Remove vp animations on team and contact pages
$f5a7455c73851c46$var$navButtons.forEach((button)=>{
    button.addEventListener("click", ()=>{
        (0, $177d6097cd356643$export$e207fdd04ad31b0)($f5a7455c73851c46$var$scene);
    });
});
const $f5a7455c73851c46$var$renderImageTexture = ()=>{
    let w, h, a;
    const z = $f5a7455c73851c46$var$remap($f5a7455c73851c46$var$PARAMS.kabaZoom, 0, 1, 0, window.innerWidth <= 900 ? 1.2 : 2);
    if ($f5a7455c73851c46$var$textureImg.height > $f5a7455c73851c46$var$textureImg.width) {
        a = $f5a7455c73851c46$var$textureImg.width / $f5a7455c73851c46$var$textureImg.height;
        h = $f5a7455c73851c46$var$SIZES.height * z;
        w = h * a;
    } else {
        a = $f5a7455c73851c46$var$textureImg.height / $f5a7455c73851c46$var$textureImg.width;
        w = $f5a7455c73851c46$var$SIZES.width * z;
        h = w * a;
    }
    $f5a7455c73851c46$var$ctx.clearRect(0, 0, $f5a7455c73851c46$var$SIZES.width, $f5a7455c73851c46$var$SIZES.height);
    $f5a7455c73851c46$var$ctx.drawImage($f5a7455c73851c46$var$textureImg, ($f5a7455c73851c46$var$SIZES.width - w) * 0.5, ($f5a7455c73851c46$var$SIZES.height - h) * 0.5, w, h);
    $f5a7455c73851c46$var$textureMaterial.uniforms.sampler.value = new $d5b85d29c0b78636$export$f7189e49152d1c13($f5a7455c73851c46$var$textureCanvas);
};

})();
//# sourceMappingURL=index.5fbba999.js.map