// threejs.org/license
// threejs.org/license
;(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined'
    ? factory(exports)
    : typeof define === 'function' && define.amd
    ? define(['exports'], factory)
    : ((global = typeof globalThis !== 'undefined' ? globalThis : global || self), factory((global.THREE = {})))
})(this, function (exports) {
  'use strict'

  // Polyfills
  if (Number.EPSILON === undefined) {
    Number.EPSILON = Math.pow(2, -52)
  }

  if (Number.isInteger === undefined) {
    // Missing in IE
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
    Number.isInteger = function (value) {
      return typeof value === 'number' && isFinite(value) && Math.floor(value) === value
    }
  } //

  if (Math.sign === undefined) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
    Math.sign = function (x) {
      return x < 0 ? -1 : x > 0 ? 1 : +x
    }
  }

  if ('name' in Function.prototype === false) {
    // Missing in IE
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
    Object.defineProperty(Function.prototype, 'name', {
      get: function get() {
        return this.toString().match(/^\s*function\s*([^\(\s]*)/)[1]
      }
    })
  }

  if (Object.assign === undefined) {
    // Missing in IE
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
    Object.assign = function (target) {
      if (target === undefined || target === null) {
        throw new TypeError('Cannot convert undefined or null to object')
      }

      var output = Object(target)

      for (var index = 1; index < arguments.length; index++) {
        var source = arguments[index]

        if (source !== undefined && source !== null) {
          for (var nextKey in source) {
            if (Object.prototype.hasOwnProperty.call(source, nextKey)) {
              output[nextKey] = source[nextKey]
            }
          }
        }
      }

      return output
    }
  }

  var REVISION = '124dev'
  var MOUSE = {
    LEFT: 0,
    MIDDLE: 1,
    RIGHT: 2,
    ROTATE: 0,
    DOLLY: 1,
    PAN: 2
  }
  var TOUCH = {
    ROTATE: 0,
    PAN: 1,
    DOLLY_PAN: 2,
    DOLLY_ROTATE: 3
  }
  var CullFaceNone = 0
  var CullFaceBack = 1
  var CullFaceFront = 2
  var CullFaceFrontBack = 3
  var BasicShadowMap = 0
  var PCFShadowMap = 1
  var PCFSoftShadowMap = 2
  var VSMShadowMap = 3
  var FrontSide = 0
  var BackSide = 1
  var DoubleSide = 2
  var FlatShading = 1
  var SmoothShading = 2
  var NoBlending = 0
  var NormalBlending = 1
  var AdditiveBlending = 2
  var SubtractiveBlending = 3
  var MultiplyBlending = 4
  var CustomBlending = 5
  var AddEquation = 100
  var SubtractEquation = 101
  var ReverseSubtractEquation = 102
  var MinEquation = 103
  var MaxEquation = 104
  var ZeroFactor = 200
  var OneFactor = 201
  var SrcColorFactor = 202
  var OneMinusSrcColorFactor = 203
  var SrcAlphaFactor = 204
  var OneMinusSrcAlphaFactor = 205
  var DstAlphaFactor = 206
  var OneMinusDstAlphaFactor = 207
  var DstColorFactor = 208
  var OneMinusDstColorFactor = 209
  var SrcAlphaSaturateFactor = 210
  var NeverDepth = 0
  var AlwaysDepth = 1
  var LessDepth = 2
  var LessEqualDepth = 3
  var EqualDepth = 4
  var GreaterEqualDepth = 5
  var GreaterDepth = 6
  var NotEqualDepth = 7
  var MultiplyOperation = 0
  var MixOperation = 1
  var AddOperation = 2
  var NoToneMapping = 0
  var LinearToneMapping = 1
  var ReinhardToneMapping = 2
  var CineonToneMapping = 3
  var ACESFilmicToneMapping = 4
  var CustomToneMapping = 5
  var UVMapping = 300
  var CubeReflectionMapping = 301
  var CubeRefractionMapping = 302
  var EquirectangularReflectionMapping = 303
  var EquirectangularRefractionMapping = 304
  var CubeUVReflectionMapping = 306
  var CubeUVRefractionMapping = 307
  var RepeatWrapping = 1000
  var ClampToEdgeWrapping = 1001
  var MirroredRepeatWrapping = 1002
  var NearestFilter = 1003
  var NearestMipmapNearestFilter = 1004
  var NearestMipMapNearestFilter = 1004
  var NearestMipmapLinearFilter = 1005
  var NearestMipMapLinearFilter = 1005
  var LinearFilter = 1006
  var LinearMipmapNearestFilter = 1007
  var LinearMipMapNearestFilter = 1007
  var LinearMipmapLinearFilter = 1008
  var LinearMipMapLinearFilter = 1008
  var UnsignedByteType = 1009
  var ByteType = 1010
  var ShortType = 1011
  var UnsignedShortType = 1012
  var IntType = 1013
  var UnsignedIntType = 1014
  var FloatType = 1015
  var HalfFloatType = 1016
  var UnsignedShort4444Type = 1017
  var UnsignedShort5551Type = 1018
  var UnsignedShort565Type = 1019
  var UnsignedInt248Type = 1020
  var AlphaFormat = 1021
  var RGBFormat = 1022
  var RGBAFormat = 1023
  var LuminanceFormat = 1024
  var LuminanceAlphaFormat = 1025
  var RGBEFormat = RGBAFormat
  var DepthFormat = 1026
  var DepthStencilFormat = 1027
  var RedFormat = 1028
  var RedIntegerFormat = 1029
  var RGFormat = 1030
  var RGIntegerFormat = 1031
  var RGBIntegerFormat = 1032
  var RGBAIntegerFormat = 1033
  var RGB_S3TC_DXT1_Format = 33776
  var RGBA_S3TC_DXT1_Format = 33777
  var RGBA_S3TC_DXT3_Format = 33778
  var RGBA_S3TC_DXT5_Format = 33779
  var RGB_PVRTC_4BPPV1_Format = 35840
  var RGB_PVRTC_2BPPV1_Format = 35841
  var RGBA_PVRTC_4BPPV1_Format = 35842
  var RGBA_PVRTC_2BPPV1_Format = 35843
  var RGB_ETC1_Format = 36196
  var RGB_ETC2_Format = 37492
  var RGBA_ETC2_EAC_Format = 37496
  var RGBA_ASTC_4x4_Format = 37808
  var RGBA_ASTC_5x4_Format = 37809
  var RGBA_ASTC_5x5_Format = 37810
  var RGBA_ASTC_6x5_Format = 37811
  var RGBA_ASTC_6x6_Format = 37812
  var RGBA_ASTC_8x5_Format = 37813
  var RGBA_ASTC_8x6_Format = 37814
  var RGBA_ASTC_8x8_Format = 37815
  var RGBA_ASTC_10x5_Format = 37816
  var RGBA_ASTC_10x6_Format = 37817
  var RGBA_ASTC_10x8_Format = 37818
  var RGBA_ASTC_10x10_Format = 37819
  var RGBA_ASTC_12x10_Format = 37820
  var RGBA_ASTC_12x12_Format = 37821
  var RGBA_BPTC_Format = 36492
  var SRGB8_ALPHA8_ASTC_4x4_Format = 37840
  var SRGB8_ALPHA8_ASTC_5x4_Format = 37841
  var SRGB8_ALPHA8_ASTC_5x5_Format = 37842
  var SRGB8_ALPHA8_ASTC_6x5_Format = 37843
  var SRGB8_ALPHA8_ASTC_6x6_Format = 37844
  var SRGB8_ALPHA8_ASTC_8x5_Format = 37845
  var SRGB8_ALPHA8_ASTC_8x6_Format = 37846
  var SRGB8_ALPHA8_ASTC_8x8_Format = 37847
  var SRGB8_ALPHA8_ASTC_10x5_Format = 37848
  var SRGB8_ALPHA8_ASTC_10x6_Format = 37849
  var SRGB8_ALPHA8_ASTC_10x8_Format = 37850
  var SRGB8_ALPHA8_ASTC_10x10_Format = 37851
  var SRGB8_ALPHA8_ASTC_12x10_Format = 37852
  var SRGB8_ALPHA8_ASTC_12x12_Format = 37853
  var LoopOnce = 2200
  var LoopRepeat = 2201
  var LoopPingPong = 2202
  var InterpolateDiscrete = 2300
  var InterpolateLinear = 2301
  var InterpolateSmooth = 2302
  var ZeroCurvatureEnding = 2400
  var ZeroSlopeEnding = 2401
  var WrapAroundEnding = 2402
  var NormalAnimationBlendMode = 2500
  var AdditiveAnimationBlendMode = 2501
  var TrianglesDrawMode = 0
  var TriangleStripDrawMode = 1
  var TriangleFanDrawMode = 2
  var LinearEncoding = 3000
  var sRGBEncoding = 3001
  var GammaEncoding = 3007
  var RGBEEncoding = 3002
  var LogLuvEncoding = 3003
  var RGBM7Encoding = 3004
  var RGBM16Encoding = 3005
  var RGBDEncoding = 3006
  var BasicDepthPacking = 3200
  var RGBADepthPacking = 3201
  var TangentSpaceNormalMap = 0
  var ObjectSpaceNormalMap = 1
  var ZeroStencilOp = 0
  var KeepStencilOp = 7680
  var ReplaceStencilOp = 7681
  var IncrementStencilOp = 7682
  var DecrementStencilOp = 7683
  var IncrementWrapStencilOp = 34055
  var DecrementWrapStencilOp = 34056
  var InvertStencilOp = 5386
  var NeverStencilFunc = 512
  var LessStencilFunc = 513
  var EqualStencilFunc = 514
  var LessEqualStencilFunc = 515
  var GreaterStencilFunc = 516
  var NotEqualStencilFunc = 517
  var GreaterEqualStencilFunc = 518
  var AlwaysStencilFunc = 519
  var StaticDrawUsage = 35044
  var DynamicDrawUsage = 35048
  var StreamDrawUsage = 35040
  var StaticReadUsage = 35045
  var DynamicReadUsage = 35049
  var StreamReadUsage = 35041
  var StaticCopyUsage = 35046
  var DynamicCopyUsage = 35050
  var StreamCopyUsage = 35042
  var GLSL1 = '100'
  var GLSL3 = '300 es'

  /**
   * https://github.com/mrdoob/eventdispatcher.js/
   */
  function EventDispatcher() {}

  Object.assign(EventDispatcher.prototype, {
    addEventListener: function addEventListener(type, listener) {
      if (this._listeners === undefined) this._listeners = {}
      var listeners = this._listeners

      if (listeners[type] === undefined) {
        listeners[type] = []
      }

      if (listeners[type].indexOf(listener) === -1) {
        listeners[type].push(listener)
      }
    },
    hasEventListener: function hasEventListener(type, listener) {
      if (this._listeners === undefined) return false
      var listeners = this._listeners
      return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1
    },
    removeEventListener: function removeEventListener(type, listener) {
      if (this._listeners === undefined) return
      var listeners = this._listeners
      var listenerArray = listeners[type]

      if (listenerArray !== undefined) {
        var index = listenerArray.indexOf(listener)

        if (index !== -1) {
          listenerArray.splice(index, 1)
        }
      }
    },
    dispatchEvent: function dispatchEvent(event) {
      if (this._listeners === undefined) return
      var listeners = this._listeners
      var listenerArray = listeners[event.type]

      if (listenerArray !== undefined) {
        event.target = this // Make a copy, in case listeners are removed while iterating.

        var array = listenerArray.slice(0)

        for (var i = 0, l = array.length; i < l; i++) {
          array[i].call(this, event)
        }
      }
    }
  })

  var _lut = []

  for (var i = 0; i < 256; i++) {
    _lut[i] = (i < 16 ? '0' : '') + i.toString(16)
  }

  var _seed = 1234567
  var MathUtils = {
    DEG2RAD: Math.PI / 180,
    RAD2DEG: 180 / Math.PI,
    generateUUID: function generateUUID() {
      // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
      var d0 = (Math.random() * 0xffffffff) | 0
      var d1 = (Math.random() * 0xffffffff) | 0
      var d2 = (Math.random() * 0xffffffff) | 0
      var d3 = (Math.random() * 0xffffffff) | 0
      var uuid =
        _lut[d0 & 0xff] +
        _lut[(d0 >> 8) & 0xff] +
        _lut[(d0 >> 16) & 0xff] +
        _lut[(d0 >> 24) & 0xff] +
        '-' +
        _lut[d1 & 0xff] +
        _lut[(d1 >> 8) & 0xff] +
        '-' +
        _lut[((d1 >> 16) & 0x0f) | 0x40] +
        _lut[(d1 >> 24) & 0xff] +
        '-' +
        _lut[(d2 & 0x3f) | 0x80] +
        _lut[(d2 >> 8) & 0xff] +
        '-' +
        _lut[(d2 >> 16) & 0xff] +
        _lut[(d2 >> 24) & 0xff] +
        _lut[d3 & 0xff] +
        _lut[(d3 >> 8) & 0xff] +
        _lut[(d3 >> 16) & 0xff] +
        _lut[(d3 >> 24) & 0xff] // .toUpperCase() here flattens concatenated strings to save heap memory space.

      return uuid.toUpperCase()
    },
    clamp: function clamp(value, min, max) {
      return Math.max(min, Math.min(max, value))
    },
    // compute euclidian modulo of m % n
    // https://en.wikipedia.org/wiki/Modulo_operation
    euclideanModulo: function euclideanModulo(n, m) {
      return ((n % m) + m) % m
    },
    // Linear mapping from range <a1, a2> to range <b1, b2>
    mapLinear: function mapLinear(x, a1, a2, b1, b2) {
      return b1 + ((x - a1) * (b2 - b1)) / (a2 - a1)
    },
    // https://en.wikipedia.org/wiki/Linear_interpolation
    lerp: function lerp(x, y, t) {
      return (1 - t) * x + t * y
    },
    // http://en.wikipedia.org/wiki/Smoothstep
    smoothstep: function 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)
    },
    smootherstep: function 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
    randInt: function randInt(low, high) {
      return low + Math.floor(Math.random() * (high - low + 1))
    },
    // Random float from <low, high> interval
    randFloat: function randFloat(low, high) {
      return low + Math.random() * (high - low)
    },
    // Random float from <-range/2, range/2> interval
    randFloatSpread: function randFloatSpread(range) {
      return range * (0.5 - Math.random())
    },
    // Deterministic pseudo-random float in the interval [ 0, 1 ]
    seededRandom: function seededRandom(s) {
      if (s !== undefined) _seed = s % 2147483647 // Park-Miller algorithm

      _seed = (_seed * 16807) % 2147483647
      return (_seed - 1) / 2147483646
    },
    degToRad: function degToRad(degrees) {
      return degrees * MathUtils.DEG2RAD
    },
    radToDeg: function radToDeg(radians) {
      return radians * MathUtils.RAD2DEG
    },
    isPowerOfTwo: function isPowerOfTwo(value) {
      return (value & (value - 1)) === 0 && value !== 0
    },
    ceilPowerOfTwo: function ceilPowerOfTwo(value) {
      return Math.pow(2, Math.ceil(Math.log(value) / Math.LN2))
    },
    floorPowerOfTwo: function floorPowerOfTwo(value) {
      return Math.pow(2, Math.floor(Math.log(value) / Math.LN2))
    },
    setQuaternionFromProperEuler: function 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
      var cos = Math.cos
      var sin = Math.sin
      var c2 = cos(b / 2)
      var s2 = sin(b / 2)
      var c13 = cos((a + c) / 2)
      var s13 = sin((a + c) / 2)
      var c1_3 = cos((a - c) / 2)
      var s1_3 = sin((a - c) / 2)
      var c3_1 = cos((c - a) / 2)
      var 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 _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i]
      descriptor.enumerable = descriptor.enumerable || false
      descriptor.configurable = true
      if ('value' in descriptor) descriptor.writable = true
      Object.defineProperty(target, descriptor.key, descriptor)
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps)
    if (staticProps) _defineProperties(Constructor, staticProps)
    return Constructor
  }

  function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype)
    subClass.prototype.constructor = subClass
    subClass.__proto__ = superClass
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called")
    }

    return self
  }

  var Vector2 = /*#__PURE__*/ (function () {
    function Vector2(x, y) {
      if (x === void 0) {
        x = 0
      }

      if (y === void 0) {
        y = 0
      }

      Object.defineProperty(this, 'isVector2', {
        value: true
      })
      this.x = x
      this.y = y
    }

    var _proto = Vector2.prototype

    _proto.set = function set(x, y) {
      this.x = x
      this.y = y
      return this
    }

    _proto.setScalar = function setScalar(scalar) {
      this.x = scalar
      this.y = scalar
      return this
    }

    _proto.setX = function setX(x) {
      this.x = x
      return this
    }

    _proto.setY = function setY(y) {
      this.y = y
      return this
    }

    _proto.setComponent = function 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
    }

    _proto.getComponent = function getComponent(index) {
      switch (index) {
        case 0:
          return this.x

        case 1:
          return this.y

        default:
          throw new Error('index is out of range: ' + index)
      }
    }

    _proto.clone = function clone() {
      return new this.constructor(this.x, this.y)
    }

    _proto.copy = function copy(v) {
      this.x = v.x
      this.y = v.y
      return this
    }

    _proto.add = function add(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.')
        return this.addVectors(v, w)
      }

      this.x += v.x
      this.y += v.y
      return this
    }

    _proto.addScalar = function addScalar(s) {
      this.x += s
      this.y += s
      return this
    }

    _proto.addVectors = function addVectors(a, b) {
      this.x = a.x + b.x
      this.y = a.y + b.y
      return this
    }

    _proto.addScaledVector = function addScaledVector(v, s) {
      this.x += v.x * s
      this.y += v.y * s
      return this
    }

    _proto.sub = function sub(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.')
        return this.subVectors(v, w)
      }

      this.x -= v.x
      this.y -= v.y
      return this
    }

    _proto.subScalar = function subScalar(s) {
      this.x -= s
      this.y -= s
      return this
    }

    _proto.subVectors = function subVectors(a, b) {
      this.x = a.x - b.x
      this.y = a.y - b.y
      return this
    }

    _proto.multiply = function multiply(v) {
      this.x *= v.x
      this.y *= v.y
      return this
    }

    _proto.multiplyScalar = function multiplyScalar(scalar) {
      this.x *= scalar
      this.y *= scalar
      return this
    }

    _proto.divide = function divide(v) {
      this.x /= v.x
      this.y /= v.y
      return this
    }

    _proto.divideScalar = function divideScalar(scalar) {
      return this.multiplyScalar(1 / scalar)
    }

    _proto.applyMatrix3 = function applyMatrix3(m) {
      var x = this.x,
        y = this.y
      var 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
    }

    _proto.min = function min(v) {
      this.x = Math.min(this.x, v.x)
      this.y = Math.min(this.y, v.y)
      return this
    }

    _proto.max = function max(v) {
      this.x = Math.max(this.x, v.x)
      this.y = Math.max(this.y, v.y)
      return this
    }

    _proto.clamp = function clamp(min, max) {
      // assumes min < max, componentwise
      this.x = Math.max(min.x, Math.min(max.x, this.x))
      this.y = Math.max(min.y, Math.min(max.y, this.y))
      return this
    }

    _proto.clampScalar = function clampScalar(minVal, maxVal) {
      this.x = Math.max(minVal, Math.min(maxVal, this.x))
      this.y = Math.max(minVal, Math.min(maxVal, this.y))
      return this
    }

    _proto.clampLength = function clampLength(min, max) {
      var length = this.length()
      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)))
    }

    _proto.floor = function floor() {
      this.x = Math.floor(this.x)
      this.y = Math.floor(this.y)
      return this
    }

    _proto.ceil = function ceil() {
      this.x = Math.ceil(this.x)
      this.y = Math.ceil(this.y)
      return this
    }

    _proto.round = function round() {
      this.x = Math.round(this.x)
      this.y = Math.round(this.y)
      return this
    }

    _proto.roundToZero = function roundToZero() {
      this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x)
      this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y)
      return this
    }

    _proto.negate = function negate() {
      this.x = -this.x
      this.y = -this.y
      return this
    }

    _proto.dot = function dot(v) {
      return this.x * v.x + this.y * v.y
    }

    _proto.cross = function cross(v) {
      return this.x * v.y - this.y * v.x
    }

    _proto.lengthSq = function lengthSq() {
      return this.x * this.x + this.y * this.y
    }

    _proto.length = function length() {
      return Math.sqrt(this.x * this.x + this.y * this.y)
    }

    _proto.manhattanLength = function manhattanLength() {
      return Math.abs(this.x) + Math.abs(this.y)
    }

    _proto.normalize = function normalize() {
      return this.divideScalar(this.length() || 1)
    }

    _proto.angle = function angle() {
      // computes the angle in radians with respect to the positive x-axis
      var angle = Math.atan2(-this.y, -this.x) + Math.PI
      return angle
    }

    _proto.distanceTo = function distanceTo(v) {
      return Math.sqrt(this.distanceToSquared(v))
    }

    _proto.distanceToSquared = function distanceToSquared(v) {
      var dx = this.x - v.x,
        dy = this.y - v.y
      return dx * dx + dy * dy
    }

    _proto.manhattanDistanceTo = function manhattanDistanceTo(v) {
      return Math.abs(this.x - v.x) + Math.abs(this.y - v.y)
    }

    _proto.setLength = function setLength(length) {
      return this.normalize().multiplyScalar(length)
    }

    _proto.lerp = function lerp(v, alpha) {
      this.x += (v.x - this.x) * alpha
      this.y += (v.y - this.y) * alpha
      return this
    }

    _proto.lerpVectors = function lerpVectors(v1, v2, alpha) {
      this.x = v1.x + (v2.x - v1.x) * alpha
      this.y = v1.y + (v2.y - v1.y) * alpha
      return this
    }

    _proto.equals = function equals(v) {
      return v.x === this.x && v.y === this.y
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      this.x = array[offset]
      this.y = array[offset + 1]
      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      array[offset] = this.x
      array[offset + 1] = this.y
      return array
    }

    _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index, offset) {
      if (offset !== undefined) {
        console.warn('THREE.Vector2: offset has been removed from .fromBufferAttribute().')
      }

      this.x = attribute.getX(index)
      this.y = attribute.getY(index)
      return this
    }

    _proto.rotateAround = function rotateAround(center, angle) {
      var c = Math.cos(angle),
        s = Math.sin(angle)
      var x = this.x - center.x
      var y = this.y - center.y
      this.x = x * c - y * s + center.x
      this.y = x * s + y * c + center.y
      return this
    }

    _proto.random = function random() {
      this.x = Math.random()
      this.y = Math.random()
      return this
    }

    _createClass(Vector2, [
      {
        key: 'width',
        get: function get() {
          return this.x
        },
        set: function set(value) {
          this.x = value
        }
      },
      {
        key: 'height',
        get: function get() {
          return this.y
        },
        set: function set(value) {
          this.y = value
        }
      }
    ])

    return Vector2
  })()

  var Matrix3 = /*#__PURE__*/ (function () {
    function Matrix3() {
      Object.defineProperty(this, 'isMatrix3', {
        value: true
      })
      this.elements = [1, 0, 0, 0, 1, 0, 0, 0, 1]

      if (arguments.length > 0) {
        console.error('THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.')
      }
    }

    var _proto = Matrix3.prototype

    _proto.set = function set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
      var 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
    }

    _proto.identity = function identity() {
      this.set(1, 0, 0, 0, 1, 0, 0, 0, 1)
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().fromArray(this.elements)
    }

    _proto.copy = function copy(m) {
      var te = this.elements
      var 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
    }

    _proto.extractBasis = function extractBasis(xAxis, yAxis, zAxis) {
      xAxis.setFromMatrix3Column(this, 0)
      yAxis.setFromMatrix3Column(this, 1)
      zAxis.setFromMatrix3Column(this, 2)
      return this
    }

    _proto.setFromMatrix4 = function setFromMatrix4(m) {
      var 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
    }

    _proto.multiply = function multiply(m) {
      return this.multiplyMatrices(this, m)
    }

    _proto.premultiply = function premultiply(m) {
      return this.multiplyMatrices(m, this)
    }

    _proto.multiplyMatrices = function multiplyMatrices(a, b) {
      var ae = a.elements
      var be = b.elements
      var te = this.elements
      var a11 = ae[0],
        a12 = ae[3],
        a13 = ae[6]
      var a21 = ae[1],
        a22 = ae[4],
        a23 = ae[7]
      var a31 = ae[2],
        a32 = ae[5],
        a33 = ae[8]
      var b11 = be[0],
        b12 = be[3],
        b13 = be[6]
      var b21 = be[1],
        b22 = be[4],
        b23 = be[7]
      var 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
    }

    _proto.multiplyScalar = function multiplyScalar(s) {
      var 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
    }

    _proto.determinant = function determinant() {
      var te = this.elements
      var 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
    }

    _proto.invert = function invert() {
      var 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)
      var 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
    }

    _proto.transpose = function transpose() {
      var tmp
      var 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
    }

    _proto.getNormalMatrix = function getNormalMatrix(matrix4) {
      return this.setFromMatrix4(matrix4).copy(this).invert().transpose()
    }

    _proto.transposeIntoArray = function transposeIntoArray(r) {
      var 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
    }

    _proto.setUvTransform = function setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
      var c = Math.cos(rotation)
      var 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
    }

    _proto.scale = function scale(sx, sy) {
      var te = this.elements
      te[0] *= sx
      te[3] *= sx
      te[6] *= sx
      te[1] *= sy
      te[4] *= sy
      te[7] *= sy
      return this
    }

    _proto.rotate = function rotate(theta) {
      var c = Math.cos(theta)
      var s = Math.sin(theta)
      var te = this.elements
      var a11 = te[0],
        a12 = te[3],
        a13 = te[6]
      var a21 = te[1],
        a22 = te[4],
        a23 = te[7]
      te[0] = c * a11 + s * a21
      te[3] = c * a12 + s * a22
      te[6] = c * a13 + s * a23
      te[1] = -s * a11 + c * a21
      te[4] = -s * a12 + c * a22
      te[7] = -s * a13 + c * a23
      return this
    }

    _proto.translate = function translate(tx, ty) {
      var te = this.elements
      te[0] += tx * te[2]
      te[3] += tx * te[5]
      te[6] += tx * te[8]
      te[1] += ty * te[2]
      te[4] += ty * te[5]
      te[7] += ty * te[8]
      return this
    }

    _proto.equals = function equals(matrix) {
      var te = this.elements
      var me = matrix.elements

      for (var i = 0; i < 9; i++) {
        if (te[i] !== me[i]) return false
      }

      return true
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      for (var i = 0; i < 9; i++) {
        this.elements[i] = array[i + offset]
      }

      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      var 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
    }

    return Matrix3
  })()

  var _canvas

  var ImageUtils = {
    getDataURL: function getDataURL(image) {
      if (/^data:/i.test(image.src)) {
        return image.src
      }

      if (typeof HTMLCanvasElement == 'undefined') {
        return image.src
      }

      var canvas

      if (image instanceof HTMLCanvasElement) {
        canvas = image
      } else {
        if (_canvas === undefined) _canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
        _canvas.width = image.width
        _canvas.height = image.height

        var context = _canvas.getContext('2d')

        if (image instanceof ImageData) {
          context.putImageData(image, 0, 0)
        } else {
          context.drawImage(image, 0, 0, image.width, image.height)
        }

        canvas = _canvas
      }

      if (canvas.width > 2048 || canvas.height > 2048) {
        return canvas.toDataURL('image/jpeg', 0.6)
      } else {
        return canvas.toDataURL('image/png')
      }
    }
  }

  var textureId = 0

  function Texture(image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding) {
    if (image === void 0) {
      image = Texture.DEFAULT_IMAGE
    }

    if (mapping === void 0) {
      mapping = Texture.DEFAULT_MAPPING
    }

    if (wrapS === void 0) {
      wrapS = ClampToEdgeWrapping
    }

    if (wrapT === void 0) {
      wrapT = ClampToEdgeWrapping
    }

    if (magFilter === void 0) {
      magFilter = LinearFilter
    }

    if (minFilter === void 0) {
      minFilter = LinearMipmapLinearFilter
    }

    if (format === void 0) {
      format = RGBAFormat
    }

    if (type === void 0) {
      type = UnsignedByteType
    }

    if (anisotropy === void 0) {
      anisotropy = 1
    }

    if (encoding === void 0) {
      encoding = LinearEncoding
    }

    Object.defineProperty(this, 'id', {
      value: textureId++
    })
    this.uuid = MathUtils.generateUUID()
    this.name = ''
    this.image = image
    this.mipmaps = []
    this.mapping = mapping
    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 Vector2(0, 0)
    this.repeat = new Vector2(1, 1)
    this.center = new Vector2(0, 0)
    this.rotation = 0
    this.matrixAutoUpdate = true
    this.matrix = new Matrix3()
    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)
    // Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
    //
    // Also changing the encoding after already used by a Material will not automatically make the Material
    // update. You need to explicitly call Material.needsUpdate to trigger it to recompile.

    this.encoding = encoding
    this.version = 0
    this.onUpdate = null
  }

  Texture.DEFAULT_IMAGE = undefined
  Texture.DEFAULT_MAPPING = UVMapping
  Texture.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Texture,
    isTexture: true,
    updateMatrix: function 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: function clone() {
      return new this.constructor().copy(this)
    },
    copy: function copy(source) {
      this.name = source.name
      this.image = source.image
      this.mipmaps = source.mipmaps.slice(0)
      this.mapping = source.mapping
      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.encoding = source.encoding
      return this
    },
    toJSON: function toJSON(meta) {
      var isRootObject = meta === undefined || typeof meta === 'string'

      if (!isRootObject && meta.textures[this.uuid] !== undefined) {
        return meta.textures[this.uuid]
      }

      var output = {
        metadata: {
          version: 4.5,
          type: 'Texture',
          generator: 'Texture.toJSON'
        },
        uuid: this.uuid,
        name: this.name,
        mapping: this.mapping,
        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,
        type: this.type,
        encoding: this.encoding,
        minFilter: this.minFilter,
        magFilter: this.magFilter,
        anisotropy: this.anisotropy,
        flipY: this.flipY,
        premultiplyAlpha: this.premultiplyAlpha,
        unpackAlignment: this.unpackAlignment
      }

      if (this.image !== undefined) {
        // TODO: Move to THREE.Image
        var image = this.image

        if (image.uuid === undefined) {
          image.uuid = MathUtils.generateUUID() // UGH
        }

        if (!isRootObject && meta.images[image.uuid] === undefined) {
          var url

          if (Array.isArray(image)) {
            // process array of images e.g. CubeTexture
            url = []

            for (var i = 0, l = image.length; i < l; i++) {
              // check cube texture with data textures
              if (image[i].isDataTexture) {
                url.push(serializeImage(image[i].image))
              } else {
                url.push(serializeImage(image[i]))
              }
            }
          } else {
            // process single image
            url = serializeImage(image)
          }

          meta.images[image.uuid] = {
            uuid: image.uuid,
            url: url
          }
        }

        output.image = image.uuid
      }

      if (!isRootObject) {
        meta.textures[this.uuid] = output
      }

      return output
    },
    dispose: function dispose() {
      this.dispatchEvent({
        type: 'dispose'
      })
    },
    transformUv: function transformUv(uv) {
      if (this.mapping !== UVMapping) return uv
      uv.applyMatrix3(this.matrix)

      if (uv.x < 0 || uv.x > 1) {
        switch (this.wrapS) {
          case RepeatWrapping:
            uv.x = uv.x - Math.floor(uv.x)
            break

          case ClampToEdgeWrapping:
            uv.x = uv.x < 0 ? 0 : 1
            break

          case MirroredRepeatWrapping:
            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 RepeatWrapping:
            uv.y = uv.y - Math.floor(uv.y)
            break

          case ClampToEdgeWrapping:
            uv.y = uv.y < 0 ? 0 : 1
            break

          case MirroredRepeatWrapping:
            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
    }
  })
  Object.defineProperty(Texture.prototype, 'needsUpdate', {
    set: function set(value) {
      if (value === true) this.version++
    }
  })

  function serializeImage(image) {
    if (
      (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement) ||
      (typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement) ||
      (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap)
    ) {
      // default images
      return ImageUtils.getDataURL(image)
    } else {
      if (image.data) {
        // images of DataTexture
        return {
          data: Array.prototype.slice.call(image.data),
          width: image.width,
          height: image.height,
          type: image.data.constructor.name
        }
      } else {
        console.warn('THREE.Texture: Unable to serialize Texture.')
        return {}
      }
    }
  }

  var Vector4 = /*#__PURE__*/ (function () {
    function Vector4(x, y, z, w) {
      if (x === void 0) {
        x = 0
      }

      if (y === void 0) {
        y = 0
      }

      if (z === void 0) {
        z = 0
      }

      if (w === void 0) {
        w = 1
      }

      Object.defineProperty(this, 'isVector4', {
        value: true
      })
      this.x = x
      this.y = y
      this.z = z
      this.w = w
    }

    var _proto = Vector4.prototype

    _proto.set = function set(x, y, z, w) {
      this.x = x
      this.y = y
      this.z = z
      this.w = w
      return this
    }

    _proto.setScalar = function setScalar(scalar) {
      this.x = scalar
      this.y = scalar
      this.z = scalar
      this.w = scalar
      return this
    }

    _proto.setX = function setX(x) {
      this.x = x
      return this
    }

    _proto.setY = function setY(y) {
      this.y = y
      return this
    }

    _proto.setZ = function setZ(z) {
      this.z = z
      return this
    }

    _proto.setW = function setW(w) {
      this.w = w
      return this
    }

    _proto.setComponent = function 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
    }

    _proto.getComponent = function 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)
      }
    }

    _proto.clone = function clone() {
      return new this.constructor(this.x, this.y, this.z, this.w)
    }

    _proto.copy = function copy(v) {
      this.x = v.x
      this.y = v.y
      this.z = v.z
      this.w = v.w !== undefined ? v.w : 1
      return this
    }

    _proto.add = function add(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.')
        return this.addVectors(v, w)
      }

      this.x += v.x
      this.y += v.y
      this.z += v.z
      this.w += v.w
      return this
    }

    _proto.addScalar = function addScalar(s) {
      this.x += s
      this.y += s
      this.z += s
      this.w += s
      return this
    }

    _proto.addVectors = function 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
    }

    _proto.addScaledVector = function 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
    }

    _proto.sub = function sub(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.')
        return this.subVectors(v, w)
      }

      this.x -= v.x
      this.y -= v.y
      this.z -= v.z
      this.w -= v.w
      return this
    }

    _proto.subScalar = function subScalar(s) {
      this.x -= s
      this.y -= s
      this.z -= s
      this.w -= s
      return this
    }

    _proto.subVectors = function 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
    }

    _proto.multiplyScalar = function multiplyScalar(scalar) {
      this.x *= scalar
      this.y *= scalar
      this.z *= scalar
      this.w *= scalar
      return this
    }

    _proto.applyMatrix4 = function applyMatrix4(m) {
      var x = this.x,
        y = this.y,
        z = this.z,
        w = this.w
      var 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
    }

    _proto.divideScalar = function divideScalar(scalar) {
      return this.multiplyScalar(1 / scalar)
    }

    _proto.setAxisAngleFromQuaternion = function 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)
      var 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
    }

    _proto.setAxisAngleFromRotationMatrix = function 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)
      var angle, x, y, z // variables for result

      var epsilon = 0.01,
        // margin to allow for rounding errors
        epsilon2 = 0.1,
        // margin to distinguish between 0 and 180 degrees
        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
        var xx = (m11 + 1) / 2
        var yy = (m22 + 1) / 2
        var zz = (m33 + 1) / 2
        var xy = (m12 + m21) / 4
        var xz = (m13 + m31) / 4
        var 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

      var 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
    }

    _proto.min = function 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
    }

    _proto.max = function 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
    }

    _proto.clamp = function clamp(min, max) {
      // assumes min < max, componentwise
      this.x = Math.max(min.x, Math.min(max.x, this.x))
      this.y = Math.max(min.y, Math.min(max.y, this.y))
      this.z = Math.max(min.z, Math.min(max.z, this.z))
      this.w = Math.max(min.w, Math.min(max.w, this.w))
      return this
    }

    _proto.clampScalar = function clampScalar(minVal, maxVal) {
      this.x = Math.max(minVal, Math.min(maxVal, this.x))
      this.y = Math.max(minVal, Math.min(maxVal, this.y))
      this.z = Math.max(minVal, Math.min(maxVal, this.z))
      this.w = Math.max(minVal, Math.min(maxVal, this.w))
      return this
    }

    _proto.clampLength = function clampLength(min, max) {
      var length = this.length()
      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)))
    }

    _proto.floor = function 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
    }

    _proto.ceil = function 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
    }

    _proto.round = function 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
    }

    _proto.roundToZero = function roundToZero() {
      this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x)
      this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y)
      this.z = this.z < 0 ? Math.ceil(this.z) : Math.floor(this.z)
      this.w = this.w < 0 ? Math.ceil(this.w) : Math.floor(this.w)
      return this
    }

    _proto.negate = function negate() {
      this.x = -this.x
      this.y = -this.y
      this.z = -this.z
      this.w = -this.w
      return this
    }

    _proto.dot = function dot(v) {
      return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w
    }

    _proto.lengthSq = function lengthSq() {
      return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w
    }

    _proto.length = function length() {
      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w)
    }

    _proto.manhattanLength = function manhattanLength() {
      return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w)
    }

    _proto.normalize = function normalize() {
      return this.divideScalar(this.length() || 1)
    }

    _proto.setLength = function setLength(length) {
      return this.normalize().multiplyScalar(length)
    }

    _proto.lerp = function 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
    }

    _proto.lerpVectors = function 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
    }

    _proto.equals = function equals(v) {
      return v.x === this.x && v.y === this.y && v.z === this.z && v.w === this.w
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      this.x = array[offset]
      this.y = array[offset + 1]
      this.z = array[offset + 2]
      this.w = array[offset + 3]
      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      array[offset] = this.x
      array[offset + 1] = this.y
      array[offset + 2] = this.z
      array[offset + 3] = this.w
      return array
    }

    _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index, offset) {
      if (offset !== undefined) {
        console.warn('THREE.Vector4: offset has been removed from .fromBufferAttribute().')
      }

      this.x = attribute.getX(index)
      this.y = attribute.getY(index)
      this.z = attribute.getZ(index)
      this.w = attribute.getW(index)
      return this
    }

    _proto.random = function random() {
      this.x = Math.random()
      this.y = Math.random()
      this.z = Math.random()
      this.w = Math.random()
      return this
    }

    _createClass(Vector4, [
      {
        key: 'width',
        get: function get() {
          return this.z
        },
        set: function set(value) {
          this.z = value
        }
      },
      {
        key: 'height',
        get: function get() {
          return this.w
        },
        set: function set(value) {
          this.w = value
        }
      }
    ])

    return Vector4
  })()

  /*
	 In options, we can specify:
	 * Texture parameters for an auto-generated target texture
	 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
	*/

  function WebGLRenderTarget(width, height, options) {
    this.width = width
    this.height = height
    this.scissor = new Vector4(0, 0, width, height)
    this.scissorTest = false
    this.viewport = new Vector4(0, 0, width, height)
    options = options || {}
    this.texture = new Texture(
      undefined,
      options.mapping,
      options.wrapS,
      options.wrapT,
      options.magFilter,
      options.minFilter,
      options.format,
      options.type,
      options.anisotropy,
      options.encoding
    )
    this.texture.image = {}
    this.texture.image.width = width
    this.texture.image.height = height
    this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false
    this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter
    this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true
    this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : false
    this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null
  }

  WebGLRenderTarget.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: WebGLRenderTarget,
    isWebGLRenderTarget: true,
    setSize: function setSize(width, height) {
      if (this.width !== width || this.height !== height) {
        this.width = width
        this.height = height
        this.texture.image.width = width
        this.texture.image.height = height
        this.dispose()
      }

      this.viewport.set(0, 0, width, height)
      this.scissor.set(0, 0, width, height)
    },
    clone: function clone() {
      return new this.constructor().copy(this)
    },
    copy: function copy(source) {
      this.width = source.width
      this.height = source.height
      this.viewport.copy(source.viewport)
      this.texture = source.texture.clone()
      this.depthBuffer = source.depthBuffer
      this.stencilBuffer = source.stencilBuffer
      this.depthTexture = source.depthTexture
      return this
    },
    dispose: function dispose() {
      this.dispatchEvent({
        type: 'dispose'
      })
    }
  })

  function WebGLMultisampleRenderTarget(width, height, options) {
    WebGLRenderTarget.call(this, width, height, options)
    this.samples = 4
  }

  WebGLMultisampleRenderTarget.prototype = Object.assign(Object.create(WebGLRenderTarget.prototype), {
    constructor: WebGLMultisampleRenderTarget,
    isWebGLMultisampleRenderTarget: true,
    copy: function copy(source) {
      WebGLRenderTarget.prototype.copy.call(this, source)
      this.samples = source.samples
      return this
    }
  })

  var Quaternion = /*#__PURE__*/ (function () {
    function Quaternion(x, y, z, w) {
      if (x === void 0) {
        x = 0
      }

      if (y === void 0) {
        y = 0
      }

      if (z === void 0) {
        z = 0
      }

      if (w === void 0) {
        w = 1
      }

      Object.defineProperty(this, 'isQuaternion', {
        value: true
      })
      this._x = x
      this._y = y
      this._z = z
      this._w = w
    }

    Quaternion.slerp = function slerp(qa, qb, qm, t) {
      return qm.copy(qa).slerp(qb, t)
    }

    Quaternion.slerpFlat = function slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
      // fuzz-free, array-based Quaternion SLERP operation
      var x0 = src0[srcOffset0 + 0],
        y0 = src0[srcOffset0 + 1],
        z0 = src0[srcOffset0 + 2],
        w0 = src0[srcOffset0 + 3]
      var x1 = src1[srcOffset1 + 0],
        y1 = src1[srcOffset1 + 1],
        z1 = src1[srcOffset1 + 2],
        w1 = src1[srcOffset1 + 3]

      if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
        var s = 1 - t
        var 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) {
          var sin = Math.sqrt(sqrSin),
            len = Math.atan2(sin, cos * dir)
          s = Math.sin(s * len) / sin
          t = Math.sin(t * len) / sin
        }

        var 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) {
          var 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
    }

    Quaternion.multiplyQuaternionsFlat = function multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
      var x0 = src0[srcOffset0]
      var y0 = src0[srcOffset0 + 1]
      var z0 = src0[srcOffset0 + 2]
      var w0 = src0[srcOffset0 + 3]
      var x1 = src1[srcOffset1]
      var y1 = src1[srcOffset1 + 1]
      var z1 = src1[srcOffset1 + 2]
      var 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
    }

    var _proto = Quaternion.prototype

    _proto.set = function set(x, y, z, w) {
      this._x = x
      this._y = y
      this._z = z
      this._w = w

      this._onChangeCallback()

      return this
    }

    _proto.clone = function clone() {
      return new this.constructor(this._x, this._y, this._z, this._w)
    }

    _proto.copy = function copy(quaternion) {
      this._x = quaternion.x
      this._y = quaternion.y
      this._z = quaternion.z
      this._w = quaternion.w

      this._onChangeCallback()

      return this
    }

    _proto.setFromEuler = function setFromEuler(euler, update) {
      if (!(euler && euler.isEuler)) {
        throw new Error('THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.')
      }

      var 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

      var cos = Math.cos
      var sin = Math.sin
      var c1 = cos(x / 2)
      var c2 = cos(y / 2)
      var c3 = cos(z / 2)
      var s1 = sin(x / 2)
      var s2 = sin(y / 2)
      var 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 !== false) this._onChangeCallback()
      return this
    }

    _proto.setFromAxisAngle = function setFromAxisAngle(axis, angle) {
      // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
      // assumes axis is normalized
      var 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
    }

    _proto.setFromRotationMatrix = function 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)
      var 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) {
        var 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) {
        var _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) {
        var _s2 = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33)

        this._w = (m13 - m31) / _s2
        this._x = (m12 + m21) / _s2
        this._y = 0.25 * _s2
        this._z = (m23 + m32) / _s2
      } else {
        var _s3 = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22)

        this._w = (m21 - m12) / _s3
        this._x = (m13 + m31) / _s3
        this._y = (m23 + m32) / _s3
        this._z = 0.25 * _s3
      }

      this._onChangeCallback()

      return this
    }

    _proto.setFromUnitVectors = function setFromUnitVectors(vFrom, vTo) {
      // assumes direction vectors vFrom and vTo are normalized
      var EPS = 0.000001
      var r = vFrom.dot(vTo) + 1

      if (r < EPS) {
        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()
    }

    _proto.angleTo = function angleTo(q) {
      return 2 * Math.acos(Math.abs(MathUtils.clamp(this.dot(q), -1, 1)))
    }

    _proto.rotateTowards = function rotateTowards(q, step) {
      var angle = this.angleTo(q)
      if (angle === 0) return this
      var t = Math.min(1, step / angle)
      this.slerp(q, t)
      return this
    }

    _proto.identity = function identity() {
      return this.set(0, 0, 0, 1)
    }

    _proto.invert = function invert() {
      // quaternion is assumed to have unit length
      return this.conjugate()
    }

    _proto.conjugate = function conjugate() {
      this._x *= -1
      this._y *= -1
      this._z *= -1

      this._onChangeCallback()

      return this
    }

    _proto.dot = function dot(v) {
      return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w
    }

    _proto.lengthSq = function lengthSq() {
      return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w
    }

    _proto.length = function length() {
      return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w)
    }

    _proto.normalize = function normalize() {
      var 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
    }

    _proto.multiply = function multiply(q, p) {
      if (p !== undefined) {
        console.warn('THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.')
        return this.multiplyQuaternions(q, p)
      }

      return this.multiplyQuaternions(this, q)
    }

    _proto.premultiply = function premultiply(q) {
      return this.multiplyQuaternions(q, this)
    }

    _proto.multiplyQuaternions = function multiplyQuaternions(a, b) {
      // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
      var qax = a._x,
        qay = a._y,
        qaz = a._z,
        qaw = a._w
      var 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
    }

    _proto.slerp = function slerp(qb, t) {
      if (t === 0) return this
      if (t === 1) return this.copy(qb)
      var x = this._x,
        y = this._y,
        z = this._z,
        w = this._w // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/

      var 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
      }

      var sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta

      if (sqrSinHalfTheta <= Number.EPSILON) {
        var 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()

        this._onChangeCallback()

        return this
      }

      var sinHalfTheta = Math.sqrt(sqrSinHalfTheta)
      var halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta)
      var 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
    }

    _proto.equals = function equals(quaternion) {
      return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        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
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      array[offset] = this._x
      array[offset + 1] = this._y
      array[offset + 2] = this._z
      array[offset + 3] = this._w
      return array
    }

    _proto.fromBufferAttribute = function 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
    }

    _proto._onChange = function _onChange(callback) {
      this._onChangeCallback = callback
      return this
    }

    _proto._onChangeCallback = function _onChangeCallback() {}

    _createClass(Quaternion, [
      {
        key: 'x',
        get: function get() {
          return this._x
        },
        set: function set(value) {
          this._x = value

          this._onChangeCallback()
        }
      },
      {
        key: 'y',
        get: function get() {
          return this._y
        },
        set: function set(value) {
          this._y = value

          this._onChangeCallback()
        }
      },
      {
        key: 'z',
        get: function get() {
          return this._z
        },
        set: function set(value) {
          this._z = value

          this._onChangeCallback()
        }
      },
      {
        key: 'w',
        get: function get() {
          return this._w
        },
        set: function set(value) {
          this._w = value

          this._onChangeCallback()
        }
      }
    ])

    return Quaternion
  })()

  var Vector3 = /*#__PURE__*/ (function () {
    function Vector3(x, y, z) {
      if (x === void 0) {
        x = 0
      }

      if (y === void 0) {
        y = 0
      }

      if (z === void 0) {
        z = 0
      }

      Object.defineProperty(this, 'isVector3', {
        value: true
      })
      this.x = x
      this.y = y
      this.z = z
    }

    var _proto = Vector3.prototype

    _proto.set = function 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
    }

    _proto.setScalar = function setScalar(scalar) {
      this.x = scalar
      this.y = scalar
      this.z = scalar
      return this
    }

    _proto.setX = function setX(x) {
      this.x = x
      return this
    }

    _proto.setY = function setY(y) {
      this.y = y
      return this
    }

    _proto.setZ = function setZ(z) {
      this.z = z
      return this
    }

    _proto.setComponent = function 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
    }

    _proto.getComponent = function 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)
      }
    }

    _proto.clone = function clone() {
      return new this.constructor(this.x, this.y, this.z)
    }

    _proto.copy = function copy(v) {
      this.x = v.x
      this.y = v.y
      this.z = v.z
      return this
    }

    _proto.add = function add(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.')
        return this.addVectors(v, w)
      }

      this.x += v.x
      this.y += v.y
      this.z += v.z
      return this
    }

    _proto.addScalar = function addScalar(s) {
      this.x += s
      this.y += s
      this.z += s
      return this
    }

    _proto.addVectors = function addVectors(a, b) {
      this.x = a.x + b.x
      this.y = a.y + b.y
      this.z = a.z + b.z
      return this
    }

    _proto.addScaledVector = function addScaledVector(v, s) {
      this.x += v.x * s
      this.y += v.y * s
      this.z += v.z * s
      return this
    }

    _proto.sub = function sub(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.')
        return this.subVectors(v, w)
      }

      this.x -= v.x
      this.y -= v.y
      this.z -= v.z
      return this
    }

    _proto.subScalar = function subScalar(s) {
      this.x -= s
      this.y -= s
      this.z -= s
      return this
    }

    _proto.subVectors = function subVectors(a, b) {
      this.x = a.x - b.x
      this.y = a.y - b.y
      this.z = a.z - b.z
      return this
    }

    _proto.multiply = function multiply(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.')
        return this.multiplyVectors(v, w)
      }

      this.x *= v.x
      this.y *= v.y
      this.z *= v.z
      return this
    }

    _proto.multiplyScalar = function multiplyScalar(scalar) {
      this.x *= scalar
      this.y *= scalar
      this.z *= scalar
      return this
    }

    _proto.multiplyVectors = function multiplyVectors(a, b) {
      this.x = a.x * b.x
      this.y = a.y * b.y
      this.z = a.z * b.z
      return this
    }

    _proto.applyEuler = function applyEuler(euler) {
      if (!(euler && euler.isEuler)) {
        console.error('THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.')
      }

      return this.applyQuaternion(_quaternion.setFromEuler(euler))
    }

    _proto.applyAxisAngle = function applyAxisAngle(axis, angle) {
      return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle))
    }

    _proto.applyMatrix3 = function applyMatrix3(m) {
      var x = this.x,
        y = this.y,
        z = this.z
      var 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
    }

    _proto.applyNormalMatrix = function applyNormalMatrix(m) {
      return this.applyMatrix3(m).normalize()
    }

    _proto.applyMatrix4 = function applyMatrix4(m) {
      var x = this.x,
        y = this.y,
        z = this.z
      var e = m.elements
      var 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
    }

    _proto.applyQuaternion = function applyQuaternion(q) {
      var x = this.x,
        y = this.y,
        z = this.z
      var qx = q.x,
        qy = q.y,
        qz = q.z,
        qw = q.w // calculate quat * vector

      var ix = qw * x + qy * z - qz * y
      var iy = qw * y + qz * x - qx * z
      var iz = qw * z + qx * y - qy * x
      var iw = -qx * x - qy * y - qz * z // calculate result * inverse quat

      this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy
      this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz
      this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx
      return this
    }

    _proto.project = function project(camera) {
      return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix)
    }

    _proto.unproject = function unproject(camera) {
      return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld)
    }

    _proto.transformDirection = function transformDirection(m) {
      // input: THREE.Matrix4 affine matrix
      // vector interpreted as a direction
      var x = this.x,
        y = this.y,
        z = this.z
      var 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()
    }

    _proto.divide = function divide(v) {
      this.x /= v.x
      this.y /= v.y
      this.z /= v.z
      return this
    }

    _proto.divideScalar = function divideScalar(scalar) {
      return this.multiplyScalar(1 / scalar)
    }

    _proto.min = function 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
    }

    _proto.max = function 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
    }

    _proto.clamp = function clamp(min, max) {
      // assumes min < max, componentwise
      this.x = Math.max(min.x, Math.min(max.x, this.x))
      this.y = Math.max(min.y, Math.min(max.y, this.y))
      this.z = Math.max(min.z, Math.min(max.z, this.z))
      return this
    }

    _proto.clampScalar = function clampScalar(minVal, maxVal) {
      this.x = Math.max(minVal, Math.min(maxVal, this.x))
      this.y = Math.max(minVal, Math.min(maxVal, this.y))
      this.z = Math.max(minVal, Math.min(maxVal, this.z))
      return this
    }

    _proto.clampLength = function clampLength(min, max) {
      var length = this.length()
      return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)))
    }

    _proto.floor = function floor() {
      this.x = Math.floor(this.x)
      this.y = Math.floor(this.y)
      this.z = Math.floor(this.z)
      return this
    }

    _proto.ceil = function ceil() {
      this.x = Math.ceil(this.x)
      this.y = Math.ceil(this.y)
      this.z = Math.ceil(this.z)
      return this
    }

    _proto.round = function round() {
      this.x = Math.round(this.x)
      this.y = Math.round(this.y)
      this.z = Math.round(this.z)
      return this
    }

    _proto.roundToZero = function roundToZero() {
      this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x)
      this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y)
      this.z = this.z < 0 ? Math.ceil(this.z) : Math.floor(this.z)
      return this
    }

    _proto.negate = function negate() {
      this.x = -this.x
      this.y = -this.y
      this.z = -this.z
      return this
    }

    _proto.dot = function dot(v) {
      return this.x * v.x + this.y * v.y + this.z * v.z
    } // TODO lengthSquared?

    _proto.lengthSq = function lengthSq() {
      return this.x * this.x + this.y * this.y + this.z * this.z
    }

    _proto.length = function length() {
      return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z)
    }

    _proto.manhattanLength = function manhattanLength() {
      return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z)
    }

    _proto.normalize = function normalize() {
      return this.divideScalar(this.length() || 1)
    }

    _proto.setLength = function setLength(length) {
      return this.normalize().multiplyScalar(length)
    }

    _proto.lerp = function 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
    }

    _proto.lerpVectors = function 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
    }

    _proto.cross = function cross(v, w) {
      if (w !== undefined) {
        console.warn('THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.')
        return this.crossVectors(v, w)
      }

      return this.crossVectors(this, v)
    }

    _proto.crossVectors = function crossVectors(a, b) {
      var ax = a.x,
        ay = a.y,
        az = a.z
      var 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
    }

    _proto.projectOnVector = function projectOnVector(v) {
      var denominator = v.lengthSq()
      if (denominator === 0) return this.set(0, 0, 0)
      var scalar = v.dot(this) / denominator
      return this.copy(v).multiplyScalar(scalar)
    }

    _proto.projectOnPlane = function projectOnPlane(planeNormal) {
      _vector.copy(this).projectOnVector(planeNormal)

      return this.sub(_vector)
    }

    _proto.reflect = function reflect(normal) {
      // reflect incident vector off plane orthogonal to normal
      // normal is assumed to have unit length
      return this.sub(_vector.copy(normal).multiplyScalar(2 * this.dot(normal)))
    }

    _proto.angleTo = function angleTo(v) {
      var denominator = Math.sqrt(this.lengthSq() * v.lengthSq())
      if (denominator === 0) return Math.PI / 2
      var theta = this.dot(v) / denominator // clamp, to handle numerical problems

      return Math.acos(MathUtils.clamp(theta, -1, 1))
    }

    _proto.distanceTo = function distanceTo(v) {
      return Math.sqrt(this.distanceToSquared(v))
    }

    _proto.distanceToSquared = function distanceToSquared(v) {
      var dx = this.x - v.x,
        dy = this.y - v.y,
        dz = this.z - v.z
      return dx * dx + dy * dy + dz * dz
    }

    _proto.manhattanDistanceTo = function manhattanDistanceTo(v) {
      return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z)
    }

    _proto.setFromSpherical = function setFromSpherical(s) {
      return this.setFromSphericalCoords(s.radius, s.phi, s.theta)
    }

    _proto.setFromSphericalCoords = function setFromSphericalCoords(radius, phi, theta) {
      var 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
    }

    _proto.setFromCylindrical = function setFromCylindrical(c) {
      return this.setFromCylindricalCoords(c.radius, c.theta, c.y)
    }

    _proto.setFromCylindricalCoords = function setFromCylindricalCoords(radius, theta, y) {
      this.x = radius * Math.sin(theta)
      this.y = y
      this.z = radius * Math.cos(theta)
      return this
    }

    _proto.setFromMatrixPosition = function setFromMatrixPosition(m) {
      var e = m.elements
      this.x = e[12]
      this.y = e[13]
      this.z = e[14]
      return this
    }

    _proto.setFromMatrixScale = function setFromMatrixScale(m) {
      var sx = this.setFromMatrixColumn(m, 0).length()
      var sy = this.setFromMatrixColumn(m, 1).length()
      var sz = this.setFromMatrixColumn(m, 2).length()
      this.x = sx
      this.y = sy
      this.z = sz
      return this
    }

    _proto.setFromMatrixColumn = function setFromMatrixColumn(m, index) {
      return this.fromArray(m.elements, index * 4)
    }

    _proto.setFromMatrix3Column = function setFromMatrix3Column(m, index) {
      return this.fromArray(m.elements, index * 3)
    }

    _proto.equals = function equals(v) {
      return v.x === this.x && v.y === this.y && v.z === this.z
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      this.x = array[offset]
      this.y = array[offset + 1]
      this.z = array[offset + 2]
      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      array[offset] = this.x
      array[offset + 1] = this.y
      array[offset + 2] = this.z
      return array
    }

    _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index, offset) {
      if (offset !== undefined) {
        console.warn('THREE.Vector3: offset has been removed from .fromBufferAttribute().')
      }

      this.x = attribute.getX(index)
      this.y = attribute.getY(index)
      this.z = attribute.getZ(index)
      return this
    }

    _proto.random = function random() {
      this.x = Math.random()
      this.y = Math.random()
      this.z = Math.random()
      return this
    }

    return Vector3
  })()

  var _vector = /*@__PURE__*/ new Vector3()

  var _quaternion = /*@__PURE__*/ new Quaternion()

  var Box3 = /*#__PURE__*/ (function () {
    function Box3(min, max) {
      Object.defineProperty(this, 'isBox3', {
        value: true
      })
      this.min = min !== undefined ? min : new Vector3(+Infinity, +Infinity, +Infinity)
      this.max = max !== undefined ? max : new Vector3(-Infinity, -Infinity, -Infinity)
    }

    var _proto = Box3.prototype

    _proto.set = function set(min, max) {
      this.min.copy(min)
      this.max.copy(max)
      return this
    }

    _proto.setFromArray = function setFromArray(array) {
      var minX = +Infinity
      var minY = +Infinity
      var minZ = +Infinity
      var maxX = -Infinity
      var maxY = -Infinity
      var maxZ = -Infinity

      for (var i = 0, l = array.length; i < l; i += 3) {
        var x = array[i]
        var y = array[i + 1]
        var z = array[i + 2]
        if (x < minX) minX = x
        if (y < minY) minY = y
        if (z < minZ) minZ = z
        if (x > maxX) maxX = x
        if (y > maxY) maxY = y
        if (z > maxZ) maxZ = z
      }

      this.min.set(minX, minY, minZ)
      this.max.set(maxX, maxY, maxZ)
      return this
    }

    _proto.setFromBufferAttribute = function setFromBufferAttribute(attribute) {
      var minX = +Infinity
      var minY = +Infinity
      var minZ = +Infinity
      var maxX = -Infinity
      var maxY = -Infinity
      var maxZ = -Infinity

      for (var i = 0, l = attribute.count; i < l; i++) {
        var x = attribute.getX(i)
        var y = attribute.getY(i)
        var z = attribute.getZ(i)
        if (x < minX) minX = x
        if (y < minY) minY = y
        if (z < minZ) minZ = z
        if (x > maxX) maxX = x
        if (y > maxY) maxY = y
        if (z > maxZ) maxZ = z
      }

      this.min.set(minX, minY, minZ)
      this.max.set(maxX, maxY, maxZ)
      return this
    }

    _proto.setFromPoints = function setFromPoints(points) {
      this.makeEmpty()

      for (var i = 0, il = points.length; i < il; i++) {
        this.expandByPoint(points[i])
      }

      return this
    }

    _proto.setFromCenterAndSize = function setFromCenterAndSize(center, size) {
      var halfSize = _vector$1.copy(size).multiplyScalar(0.5)

      this.min.copy(center).sub(halfSize)
      this.max.copy(center).add(halfSize)
      return this
    }

    _proto.setFromObject = function setFromObject(object) {
      this.makeEmpty()
      return this.expandByObject(object)
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(box) {
      this.min.copy(box.min)
      this.max.copy(box.max)
      return this
    }

    _proto.makeEmpty = function makeEmpty() {
      this.min.x = this.min.y = this.min.z = +Infinity
      this.max.x = this.max.y = this.max.z = -Infinity
      return this
    }

    _proto.isEmpty = function 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
    }

    _proto.getCenter = function getCenter(target) {
      if (target === undefined) {
        console.warn('THREE.Box3: .getCenter() target is now required')
        target = new Vector3()
      }

      return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5)
    }

    _proto.getSize = function getSize(target) {
      if (target === undefined) {
        console.warn('THREE.Box3: .getSize() target is now required')
        target = new Vector3()
      }

      return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min)
    }

    _proto.expandByPoint = function expandByPoint(point) {
      this.min.min(point)
      this.max.max(point)
      return this
    }

    _proto.expandByVector = function expandByVector(vector) {
      this.min.sub(vector)
      this.max.add(vector)
      return this
    }

    _proto.expandByScalar = function expandByScalar(scalar) {
      this.min.addScalar(-scalar)
      this.max.addScalar(scalar)
      return this
    }

    _proto.expandByObject = function expandByObject(object) {
      // 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)
      var geometry = object.geometry

      if (geometry !== undefined) {
        if (geometry.boundingBox === null) {
          geometry.computeBoundingBox()
        }

        _box.copy(geometry.boundingBox)

        _box.applyMatrix4(object.matrixWorld)

        this.union(_box)
      }

      var children = object.children

      for (var i = 0, l = children.length; i < l; i++) {
        this.expandByObject(children[i])
      }

      return this
    }

    _proto.containsPoint = function 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 ? false : true
    }

    _proto.containsBox = function 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
      )
    }

    _proto.getParameter = function getParameter(point, target) {
      // This can potentially have a divide by zero if the box
      // has a size dimension of 0.
      if (target === undefined) {
        console.warn('THREE.Box3: .getParameter() target is now required')
        target = new Vector3()
      }

      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)
      )
    }

    _proto.intersectsBox = function 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
        ? false
        : true
    }

    _proto.intersectsSphere = function intersectsSphere(sphere) {
      // Find the point on the AABB closest to the sphere center.
      this.clampPoint(sphere.center, _vector$1) // If that point is inside the sphere, the AABB and sphere intersect.

      return _vector$1.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius
    }

    _proto.intersectsPlane = function 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.
      var 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
    }

    _proto.intersectsTriangle = function intersectsTriangle(triangle) {
      if (this.isEmpty()) {
        return false
      } // compute box center and extents

      this.getCenter(_center)

      _extents.subVectors(this.max, _center) // translate triangle to aabb origin

      _v0.subVectors(triangle.a, _center)

      _v1.subVectors(triangle.b, _center)

      _v2.subVectors(triangle.c, _center) // compute edge vectors for triangle

      _f0.subVectors(_v1, _v0)

      _f1.subVectors(_v2, _v1)

      _f2.subVectors(_v0, _v2) // 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)

      var axes = [
        0,
        -_f0.z,
        _f0.y,
        0,
        -_f1.z,
        _f1.y,
        0,
        -_f2.z,
        _f2.y,
        _f0.z,
        0,
        -_f0.x,
        _f1.z,
        0,
        -_f1.x,
        _f2.z,
        0,
        -_f2.x,
        -_f0.y,
        _f0.x,
        0,
        -_f1.y,
        _f1.x,
        0,
        -_f2.y,
        _f2.x,
        0
      ]

      if (!satForAxes(axes, _v0, _v1, _v2, _extents)) {
        return false
      } // test 3 face normals from the aabb

      axes = [1, 0, 0, 0, 1, 0, 0, 0, 1]

      if (!satForAxes(axes, _v0, _v1, _v2, _extents)) {
        return false
      } // finally testing the face normal of the triangle
      // use already existing triangle edge vectors here

      _triangleNormal.crossVectors(_f0, _f1)

      axes = [_triangleNormal.x, _triangleNormal.y, _triangleNormal.z]
      return satForAxes(axes, _v0, _v1, _v2, _extents)
    }

    _proto.clampPoint = function clampPoint(point, target) {
      if (target === undefined) {
        console.warn('THREE.Box3: .clampPoint() target is now required')
        target = new Vector3()
      }

      return target.copy(point).clamp(this.min, this.max)
    }

    _proto.distanceToPoint = function distanceToPoint(point) {
      var clampedPoint = _vector$1.copy(point).clamp(this.min, this.max)

      return clampedPoint.sub(point).length()
    }

    _proto.getBoundingSphere = function getBoundingSphere(target) {
      if (target === undefined) {
        console.error('THREE.Box3: .getBoundingSphere() target is now required') //target = new Sphere(); // removed to avoid cyclic dependency
      }

      this.getCenter(target.center)
      target.radius = this.getSize(_vector$1).length() * 0.5
      return target
    }

    _proto.intersect = function 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
    }

    _proto.union = function union(box) {
      this.min.min(box.min)
      this.max.max(box.max)
      return this
    }

    _proto.applyMatrix4 = function 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

      _points[0].set(this.min.x, this.min.y, this.min.z).applyMatrix4(matrix) // 000

      _points[1].set(this.min.x, this.min.y, this.max.z).applyMatrix4(matrix) // 001

      _points[2].set(this.min.x, this.max.y, this.min.z).applyMatrix4(matrix) // 010

      _points[3].set(this.min.x, this.max.y, this.max.z).applyMatrix4(matrix) // 011

      _points[4].set(this.max.x, this.min.y, this.min.z).applyMatrix4(matrix) // 100

      _points[5].set(this.max.x, this.min.y, this.max.z).applyMatrix4(matrix) // 101

      _points[6].set(this.max.x, this.max.y, this.min.z).applyMatrix4(matrix) // 110

      _points[7].set(this.max.x, this.max.y, this.max.z).applyMatrix4(matrix) // 111

      this.setFromPoints(_points)
      return this
    }

    _proto.translate = function translate(offset) {
      this.min.add(offset)
      this.max.add(offset)
      return this
    }

    _proto.equals = function equals(box) {
      return box.min.equals(this.min) && box.max.equals(this.max)
    }

    return Box3
  })()

  function satForAxes(axes, v0, v1, v2, extents) {
    for (var i = 0, j = axes.length - 3; i <= j; i += 3) {
      _testAxis.fromArray(axes, i) // project the aabb onto the seperating axis

      var r = extents.x * Math.abs(_testAxis.x) + extents.y * Math.abs(_testAxis.y) + extents.z * Math.abs(_testAxis.z) // project all 3 vertices of the triangle onto the seperating axis

      var p0 = v0.dot(_testAxis)
      var p1 = v1.dot(_testAxis)
      var p2 = v2.dot(_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 seperating and we can exit
        return false
      }
    }

    return true
  }

  var _points = [
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3(),
    /*@__PURE__*/ new Vector3()
  ]

  var _vector$1 = /*@__PURE__*/ new Vector3()

  var _box = /*@__PURE__*/ new Box3() // triangle centered vertices

  var _v0 = /*@__PURE__*/ new Vector3()

  var _v1 = /*@__PURE__*/ new Vector3()

  var _v2 = /*@__PURE__*/ new Vector3() // triangle edge vectors

  var _f0 = /*@__PURE__*/ new Vector3()

  var _f1 = /*@__PURE__*/ new Vector3()

  var _f2 = /*@__PURE__*/ new Vector3()

  var _center = /*@__PURE__*/ new Vector3()

  var _extents = /*@__PURE__*/ new Vector3()

  var _triangleNormal = /*@__PURE__*/ new Vector3()

  var _testAxis = /*@__PURE__*/ new Vector3()

  var _box$1 = /*@__PURE__*/ new Box3()

  var Sphere = /*#__PURE__*/ (function () {
    function Sphere(center, radius) {
      this.center = center !== undefined ? center : new Vector3()
      this.radius = radius !== undefined ? radius : -1
    }

    var _proto = Sphere.prototype

    _proto.set = function set(center, radius) {
      this.center.copy(center)
      this.radius = radius
      return this
    }

    _proto.setFromPoints = function setFromPoints(points, optionalCenter) {
      var center = this.center

      if (optionalCenter !== undefined) {
        center.copy(optionalCenter)
      } else {
        _box$1.setFromPoints(points).getCenter(center)
      }

      var maxRadiusSq = 0

      for (var i = 0, il = points.length; i < il; i++) {
        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(points[i]))
      }

      this.radius = Math.sqrt(maxRadiusSq)
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(sphere) {
      this.center.copy(sphere.center)
      this.radius = sphere.radius
      return this
    }

    _proto.isEmpty = function isEmpty() {
      return this.radius < 0
    }

    _proto.makeEmpty = function makeEmpty() {
      this.center.set(0, 0, 0)
      this.radius = -1
      return this
    }

    _proto.containsPoint = function containsPoint(point) {
      return point.distanceToSquared(this.center) <= this.radius * this.radius
    }

    _proto.distanceToPoint = function distanceToPoint(point) {
      return point.distanceTo(this.center) - this.radius
    }

    _proto.intersectsSphere = function intersectsSphere(sphere) {
      var radiusSum = this.radius + sphere.radius
      return sphere.center.distanceToSquared(this.center) <= radiusSum * radiusSum
    }

    _proto.intersectsBox = function intersectsBox(box) {
      return box.intersectsSphere(this)
    }

    _proto.intersectsPlane = function intersectsPlane(plane) {
      return Math.abs(plane.distanceToPoint(this.center)) <= this.radius
    }

    _proto.clampPoint = function clampPoint(point, target) {
      var deltaLengthSq = this.center.distanceToSquared(point)

      if (target === undefined) {
        console.warn('THREE.Sphere: .clampPoint() target is now required')
        target = new Vector3()
      }

      target.copy(point)

      if (deltaLengthSq > this.radius * this.radius) {
        target.sub(this.center).normalize()
        target.multiplyScalar(this.radius).add(this.center)
      }

      return target
    }

    _proto.getBoundingBox = function getBoundingBox(target) {
      if (target === undefined) {
        console.warn('THREE.Sphere: .getBoundingBox() target is now required')
        target = new Box3()
      }

      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
    }

    _proto.applyMatrix4 = function applyMatrix4(matrix) {
      this.center.applyMatrix4(matrix)
      this.radius = this.radius * matrix.getMaxScaleOnAxis()
      return this
    }

    _proto.translate = function translate(offset) {
      this.center.add(offset)
      return this
    }

    _proto.equals = function equals(sphere) {
      return sphere.center.equals(this.center) && sphere.radius === this.radius
    }

    return Sphere
  })()

  var _vector$2 = /*@__PURE__*/ new Vector3()

  var _segCenter = /*@__PURE__*/ new Vector3()

  var _segDir = /*@__PURE__*/ new Vector3()

  var _diff = /*@__PURE__*/ new Vector3()

  var _edge1 = /*@__PURE__*/ new Vector3()

  var _edge2 = /*@__PURE__*/ new Vector3()

  var _normal = /*@__PURE__*/ new Vector3()

  var Ray = /*#__PURE__*/ (function () {
    function Ray(origin, direction) {
      this.origin = origin !== undefined ? origin : new Vector3()
      this.direction = direction !== undefined ? direction : new Vector3(0, 0, -1)
    }

    var _proto = Ray.prototype

    _proto.set = function set(origin, direction) {
      this.origin.copy(origin)
      this.direction.copy(direction)
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(ray) {
      this.origin.copy(ray.origin)
      this.direction.copy(ray.direction)
      return this
    }

    _proto.at = function at(t, target) {
      if (target === undefined) {
        console.warn('THREE.Ray: .at() target is now required')
        target = new Vector3()
      }

      return target.copy(this.direction).multiplyScalar(t).add(this.origin)
    }

    _proto.lookAt = function lookAt(v) {
      this.direction.copy(v).sub(this.origin).normalize()
      return this
    }

    _proto.recast = function recast(t) {
      this.origin.copy(this.at(t, _vector$2))
      return this
    }

    _proto.closestPointToPoint = function closestPointToPoint(point, target) {
      if (target === undefined) {
        console.warn('THREE.Ray: .closestPointToPoint() target is now required')
        target = new Vector3()
      }

      target.subVectors(point, this.origin)
      var directionDistance = target.dot(this.direction)

      if (directionDistance < 0) {
        return target.copy(this.origin)
      }

      return target.copy(this.direction).multiplyScalar(directionDistance).add(this.origin)
    }

    _proto.distanceToPoint = function distanceToPoint(point) {
      return Math.sqrt(this.distanceSqToPoint(point))
    }

    _proto.distanceSqToPoint = function distanceSqToPoint(point) {
      var directionDistance = _vector$2.subVectors(point, this.origin).dot(this.direction) // point behind the ray

      if (directionDistance < 0) {
        return this.origin.distanceToSquared(point)
      }

      _vector$2.copy(this.direction).multiplyScalar(directionDistance).add(this.origin)

      return _vector$2.distanceToSquared(point)
    }

    _proto.distanceSqToSegment = function distanceSqToSegment(v0, v1, optionalPointOnRay, optionalPointOnSegment) {
      // from http://www.geometrictools.com/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
      _segCenter.copy(v0).add(v1).multiplyScalar(0.5)

      _segDir.copy(v1).sub(v0).normalize()

      _diff.copy(this.origin).sub(_segCenter)

      var segExtent = v0.distanceTo(v1) * 0.5
      var a01 = -this.direction.dot(_segDir)

      var b0 = _diff.dot(this.direction)

      var b1 = -_diff.dot(_segDir)

      var c = _diff.lengthSq()

      var det = Math.abs(1 - a01 * a01)
      var 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.
              var 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.direction).multiplyScalar(s0).add(this.origin)
      }

      if (optionalPointOnSegment) {
        optionalPointOnSegment.copy(_segDir).multiplyScalar(s1).add(_segCenter)
      }

      return sqrDist
    }

    _proto.intersectSphere = function intersectSphere(sphere, target) {
      _vector$2.subVectors(sphere.center, this.origin)

      var tca = _vector$2.dot(this.direction)

      var d2 = _vector$2.dot(_vector$2) - tca * tca
      var radius2 = sphere.radius * sphere.radius
      if (d2 > radius2) return null
      var thc = Math.sqrt(radius2 - d2) // t0 = first intersect point - entrance on front of sphere

      var t0 = tca - thc // t1 = second intersect point - exit point on back of sphere

      var t1 = tca + thc // test to see if both t0 and t1 are behind the ray - if so, return null

      if (t0 < 0 && 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)
    }

    _proto.intersectsSphere = function intersectsSphere(sphere) {
      return this.distanceSqToPoint(sphere.center) <= sphere.radius * sphere.radius
    }

    _proto.distanceToPlane = function distanceToPlane(plane) {
      var 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
      }

      var t = -(this.origin.dot(plane.normal) + plane.constant) / denominator // Return if the ray never intersects the plane

      return t >= 0 ? t : null
    }

    _proto.intersectPlane = function intersectPlane(plane, target) {
      var t = this.distanceToPlane(plane)

      if (t === null) {
        return null
      }

      return this.at(t, target)
    }

    _proto.intersectsPlane = function intersectsPlane(plane) {
      // check if the ray lies on the plane first
      var distToPoint = plane.distanceToPoint(this.origin)

      if (distToPoint === 0) {
        return true
      }

      var 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
    }

    _proto.intersectBox = function intersectBox(box, target) {
      var tmin, tmax, tymin, tymax, tzmin, tzmax
      var invdirx = 1 / this.direction.x,
        invdiry = 1 / this.direction.y,
        invdirz = 1 / this.direction.z
      var 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 // These lines also handle the case where tmin or tmax is NaN
      // (result of 0 * Infinity). x !== x returns true if x is NaN

      if (tymin > tmin || tmin !== tmin) tmin = tymin
      if (tymax < tmax || tmax !== 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)
    }

    _proto.intersectsBox = function intersectsBox(box) {
      return this.intersectBox(box, _vector$2) !== null
    }

    _proto.intersectTriangle = function intersectTriangle(a, b, c, backfaceCulling, target) {
      // Compute the offset origin, edges, and normal.
      // from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
      _edge1.subVectors(b, a)

      _edge2.subVectors(c, a)

      _normal.crossVectors(_edge1, _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)

      var DdN = this.direction.dot(_normal)
      var sign

      if (DdN > 0) {
        if (backfaceCulling) return null
        sign = 1
      } else if (DdN < 0) {
        sign = -1
        DdN = -DdN
      } else {
        return null
      }

      _diff.subVectors(this.origin, a)

      var DdQxE2 = sign * this.direction.dot(_edge2.crossVectors(_diff, _edge2)) // b1 < 0, no intersection

      if (DdQxE2 < 0) {
        return null
      }

      var DdE1xQ = sign * this.direction.dot(_edge1.cross(_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.

      var QdN = -sign * _diff.dot(_normal) // t < 0, no intersection

      if (QdN < 0) {
        return null
      } // Ray intersects triangle.

      return this.at(QdN / DdN, target)
    }

    _proto.applyMatrix4 = function applyMatrix4(matrix4) {
      this.origin.applyMatrix4(matrix4)
      this.direction.transformDirection(matrix4)
      return this
    }

    _proto.equals = function equals(ray) {
      return ray.origin.equals(this.origin) && ray.direction.equals(this.direction)
    }

    return Ray
  })()

  var Matrix4 = /*#__PURE__*/ (function () {
    function Matrix4() {
      Object.defineProperty(this, 'isMatrix4', {
        value: true
      })
      this.elements = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]

      if (arguments.length > 0) {
        console.error('THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.')
      }
    }

    var _proto = Matrix4.prototype

    _proto.set = function set(n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44) {
      var 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
    }

    _proto.identity = function identity() {
      this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
      return this
    }

    _proto.clone = function clone() {
      return new Matrix4().fromArray(this.elements)
    }

    _proto.copy = function copy(m) {
      var te = this.elements
      var 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
    }

    _proto.copyPosition = function copyPosition(m) {
      var te = this.elements,
        me = m.elements
      te[12] = me[12]
      te[13] = me[13]
      te[14] = me[14]
      return this
    }

    _proto.extractBasis = function extractBasis(xAxis, yAxis, zAxis) {
      xAxis.setFromMatrixColumn(this, 0)
      yAxis.setFromMatrixColumn(this, 1)
      zAxis.setFromMatrixColumn(this, 2)
      return this
    }

    _proto.makeBasis = function 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
    }

    _proto.extractRotation = function extractRotation(m) {
      // this method does not support reflection matrices
      var te = this.elements
      var me = m.elements

      var scaleX = 1 / _v1$1.setFromMatrixColumn(m, 0).length()

      var scaleY = 1 / _v1$1.setFromMatrixColumn(m, 1).length()

      var scaleZ = 1 / _v1$1.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
    }

    _proto.makeRotationFromEuler = function makeRotationFromEuler(euler) {
      if (!(euler && euler.isEuler)) {
        console.error('THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.')
      }

      var te = this.elements
      var x = euler.x,
        y = euler.y,
        z = euler.z
      var a = Math.cos(x),
        b = Math.sin(x)
      var c = Math.cos(y),
        d = Math.sin(y)
      var e = Math.cos(z),
        f = Math.sin(z)

      if (euler.order === 'XYZ') {
        var 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') {
        var 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') {
        var _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') {
        var _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') {
        var 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') {
        var _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
    }

    _proto.makeRotationFromQuaternion = function makeRotationFromQuaternion(q) {
      return this.compose(_zero, q, _one)
    }

    _proto.lookAt = function lookAt(eye, target, up) {
      var te = this.elements

      _z.subVectors(eye, target)

      if (_z.lengthSq() === 0) {
        // eye and target are in the same position
        _z.z = 1
      }

      _z.normalize()

      _x.crossVectors(up, _z)

      if (_x.lengthSq() === 0) {
        // up and z are parallel
        if (Math.abs(up.z) === 1) {
          _z.x += 0.0001
        } else {
          _z.z += 0.0001
        }

        _z.normalize()

        _x.crossVectors(up, _z)
      }

      _x.normalize()

      _y.crossVectors(_z, _x)

      te[0] = _x.x
      te[4] = _y.x
      te[8] = _z.x
      te[1] = _x.y
      te[5] = _y.y
      te[9] = _z.y
      te[2] = _x.z
      te[6] = _y.z
      te[10] = _z.z
      return this
    }

    _proto.multiply = function multiply(m, n) {
      if (n !== undefined) {
        console.warn('THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.')
        return this.multiplyMatrices(m, n)
      }

      return this.multiplyMatrices(this, m)
    }

    _proto.premultiply = function premultiply(m) {
      return this.multiplyMatrices(m, this)
    }

    _proto.multiplyMatrices = function multiplyMatrices(a, b) {
      var ae = a.elements
      var be = b.elements
      var te = this.elements
      var a11 = ae[0],
        a12 = ae[4],
        a13 = ae[8],
        a14 = ae[12]
      var a21 = ae[1],
        a22 = ae[5],
        a23 = ae[9],
        a24 = ae[13]
      var a31 = ae[2],
        a32 = ae[6],
        a33 = ae[10],
        a34 = ae[14]
      var a41 = ae[3],
        a42 = ae[7],
        a43 = ae[11],
        a44 = ae[15]
      var b11 = be[0],
        b12 = be[4],
        b13 = be[8],
        b14 = be[12]
      var b21 = be[1],
        b22 = be[5],
        b23 = be[9],
        b24 = be[13]
      var b31 = be[2],
        b32 = be[6],
        b33 = be[10],
        b34 = be[14]
      var 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
    }

    _proto.multiplyScalar = function multiplyScalar(s) {
      var 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
    }

    _proto.determinant = function determinant() {
      var te = this.elements
      var n11 = te[0],
        n12 = te[4],
        n13 = te[8],
        n14 = te[12]
      var n21 = te[1],
        n22 = te[5],
        n23 = te[9],
        n24 = te[13]
      var n31 = te[2],
        n32 = te[6],
        n33 = te[10],
        n34 = te[14]
      var 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)
      )
    }

    _proto.transpose = function transpose() {
      var te = this.elements
      var 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
    }

    _proto.setPosition = function setPosition(x, y, z) {
      var 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
    }

    _proto.invert = function invert() {
      // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
      var 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
      var 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)
      var 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
    }

    _proto.scale = function scale(v) {
      var te = this.elements
      var 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
    }

    _proto.getMaxScaleOnAxis = function getMaxScaleOnAxis() {
      var te = this.elements
      var scaleXSq = te[0] * te[0] + te[1] * te[1] + te[2] * te[2]
      var scaleYSq = te[4] * te[4] + te[5] * te[5] + te[6] * te[6]
      var scaleZSq = te[8] * te[8] + te[9] * te[9] + te[10] * te[10]
      return Math.sqrt(Math.max(scaleXSq, scaleYSq, scaleZSq))
    }

    _proto.makeTranslation = function makeTranslation(x, y, z) {
      this.set(1, 0, 0, x, 0, 1, 0, y, 0, 0, 1, z, 0, 0, 0, 1)
      return this
    }

    _proto.makeRotationX = function makeRotationX(theta) {
      var 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
    }

    _proto.makeRotationY = function makeRotationY(theta) {
      var 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
    }

    _proto.makeRotationZ = function makeRotationZ(theta) {
      var 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
    }

    _proto.makeRotationAxis = function makeRotationAxis(axis, angle) {
      // Based on http://www.gamedev.net/reference/articles/article1199.asp
      var c = Math.cos(angle)
      var s = Math.sin(angle)
      var t = 1 - c
      var x = axis.x,
        y = axis.y,
        z = axis.z
      var 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
    }

    _proto.makeScale = function makeScale(x, y, z) {
      this.set(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1)
      return this
    }

    _proto.makeShear = function makeShear(x, y, z) {
      this.set(1, y, z, 0, x, 1, z, 0, x, y, 1, 0, 0, 0, 0, 1)
      return this
    }

    _proto.compose = function compose(position, quaternion, scale) {
      var te = this.elements
      var x = quaternion._x,
        y = quaternion._y,
        z = quaternion._z,
        w = quaternion._w
      var x2 = x + x,
        y2 = y + y,
        z2 = z + z
      var xx = x * x2,
        xy = x * y2,
        xz = x * z2
      var yy = y * y2,
        yz = y * z2,
        zz = z * z2
      var wx = w * x2,
        wy = w * y2,
        wz = w * z2
      var 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
    }

    _proto.decompose = function decompose(position, quaternion, scale) {
      var te = this.elements

      var sx = _v1$1.set(te[0], te[1], te[2]).length()

      var sy = _v1$1.set(te[4], te[5], te[6]).length()

      var sz = _v1$1.set(te[8], te[9], te[10]).length() // if determine is negative, we need to invert one scale

      var det = this.determinant()
      if (det < 0) sx = -sx
      position.x = te[12]
      position.y = te[13]
      position.z = te[14] // scale the rotation part

      _m1.copy(this)

      var invSX = 1 / sx
      var invSY = 1 / sy
      var invSZ = 1 / sz
      _m1.elements[0] *= invSX
      _m1.elements[1] *= invSX
      _m1.elements[2] *= invSX
      _m1.elements[4] *= invSY
      _m1.elements[5] *= invSY
      _m1.elements[6] *= invSY
      _m1.elements[8] *= invSZ
      _m1.elements[9] *= invSZ
      _m1.elements[10] *= invSZ
      quaternion.setFromRotationMatrix(_m1)
      scale.x = sx
      scale.y = sy
      scale.z = sz
      return this
    }

    _proto.makePerspective = function makePerspective(left, right, top, bottom, near, far) {
      if (far === undefined) {
        console.warn('THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.')
      }

      var te = this.elements
      var x = (2 * near) / (right - left)
      var y = (2 * near) / (top - bottom)
      var a = (right + left) / (right - left)
      var b = (top + bottom) / (top - bottom)
      var c = -(far + near) / (far - near)
      var d = (-2 * far * near) / (far - near)
      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
    }

    _proto.makeOrthographic = function makeOrthographic(left, right, top, bottom, near, far) {
      var te = this.elements
      var w = 1.0 / (right - left)
      var h = 1.0 / (top - bottom)
      var p = 1.0 / (far - near)
      var x = (right + left) * w
      var y = (top + bottom) * h
      var z = (far + near) * p
      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] = -2 * p
      te[14] = -z
      te[3] = 0
      te[7] = 0
      te[11] = 0
      te[15] = 1
      return this
    }

    _proto.equals = function equals(matrix) {
      var te = this.elements
      var me = matrix.elements

      for (var i = 0; i < 16; i++) {
        if (te[i] !== me[i]) return false
      }

      return true
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      for (var i = 0; i < 16; i++) {
        this.elements[i] = array[i + offset]
      }

      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      var 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
    }

    return Matrix4
  })()

  var _v1$1 = /*@__PURE__*/ new Vector3()

  var _m1 = /*@__PURE__*/ new Matrix4()

  var _zero = /*@__PURE__*/ new Vector3(0, 0, 0)

  var _one = /*@__PURE__*/ new Vector3(1, 1, 1)

  var _x = /*@__PURE__*/ new Vector3()

  var _y = /*@__PURE__*/ new Vector3()

  var _z = /*@__PURE__*/ new Vector3()

  var Euler = /*#__PURE__*/ (function () {
    function Euler(x, y, z, order) {
      if (x === void 0) {
        x = 0
      }

      if (y === void 0) {
        y = 0
      }

      if (z === void 0) {
        z = 0
      }

      if (order === void 0) {
        order = Euler.DefaultOrder
      }

      Object.defineProperty(this, 'isEuler', {
        value: true
      })
      this._x = x
      this._y = y
      this._z = z
      this._order = order
    }

    var _proto = Euler.prototype

    _proto.set = function set(x, y, z, order) {
      this._x = x
      this._y = y
      this._z = z
      this._order = order || this._order

      this._onChangeCallback()

      return this
    }

    _proto.clone = function clone() {
      return new this.constructor(this._x, this._y, this._z, this._order)
    }

    _proto.copy = function copy(euler) {
      this._x = euler._x
      this._y = euler._y
      this._z = euler._z
      this._order = euler._order

      this._onChangeCallback()

      return this
    }

    _proto.setFromRotationMatrix = function setFromRotationMatrix(m, order, update) {
      var clamp = MathUtils.clamp // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)

      var te = m.elements
      var m11 = te[0],
        m12 = te[4],
        m13 = te[8]
      var m21 = te[1],
        m22 = te[5],
        m23 = te[9]
      var m31 = te[2],
        m32 = te[6],
        m33 = te[10]
      order = order || this._order

      switch (order) {
        case 'XYZ':
          this._y = Math.asin(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(-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(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(-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(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(-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 !== false) this._onChangeCallback()
      return this
    }

    _proto.setFromQuaternion = function setFromQuaternion(q, order, update) {
      _matrix.makeRotationFromQuaternion(q)

      return this.setFromRotationMatrix(_matrix, order, update)
    }

    _proto.setFromVector3 = function setFromVector3(v, order) {
      return this.set(v.x, v.y, v.z, order || this._order)
    }

    _proto.reorder = function reorder(newOrder) {
      // WARNING: this discards revolution information -bhouston
      _quaternion$1.setFromEuler(this)

      return this.setFromQuaternion(_quaternion$1, newOrder)
    }

    _proto.equals = function equals(euler) {
      return euler._x === this._x && euler._y === this._y && euler._z === this._z && euler._order === this._order
    }

    _proto.fromArray = function 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
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      array[offset] = this._x
      array[offset + 1] = this._y
      array[offset + 2] = this._z
      array[offset + 3] = this._order
      return array
    }

    _proto.toVector3 = function toVector3(optionalResult) {
      if (optionalResult) {
        return optionalResult.set(this._x, this._y, this._z)
      } else {
        return new Vector3(this._x, this._y, this._z)
      }
    }

    _proto._onChange = function _onChange(callback) {
      this._onChangeCallback = callback
      return this
    }

    _proto._onChangeCallback = function _onChangeCallback() {}

    _createClass(Euler, [
      {
        key: 'x',
        get: function get() {
          return this._x
        },
        set: function set(value) {
          this._x = value

          this._onChangeCallback()
        }
      },
      {
        key: 'y',
        get: function get() {
          return this._y
        },
        set: function set(value) {
          this._y = value

          this._onChangeCallback()
        }
      },
      {
        key: 'z',
        get: function get() {
          return this._z
        },
        set: function set(value) {
          this._z = value

          this._onChangeCallback()
        }
      },
      {
        key: 'order',
        get: function get() {
          return this._order
        },
        set: function set(value) {
          this._order = value

          this._onChangeCallback()
        }
      }
    ])

    return Euler
  })()

  Euler.DefaultOrder = 'XYZ'
  Euler.RotationOrders = ['XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX']

  var _matrix = /*@__PURE__*/ new Matrix4()

  var _quaternion$1 = /*@__PURE__*/ new Quaternion()

  var Layers = /*#__PURE__*/ (function () {
    function Layers() {
      this.mask = 1 | 0
    }

    var _proto = Layers.prototype

    _proto.set = function set(channel) {
      this.mask = (1 << channel) | 0
    }

    _proto.enable = function enable(channel) {
      this.mask |= (1 << channel) | 0
    }

    _proto.enableAll = function enableAll() {
      this.mask = 0xffffffff | 0
    }

    _proto.toggle = function toggle(channel) {
      this.mask ^= (1 << channel) | 0
    }

    _proto.disable = function disable(channel) {
      this.mask &= ~((1 << channel) | 0)
    }

    _proto.disableAll = function disableAll() {
      this.mask = 0
    }

    _proto.test = function test(layers) {
      return (this.mask & layers.mask) !== 0
    }

    return Layers
  })()

  var _object3DId = 0

  var _v1$2 = new Vector3()

  var _q1 = new Quaternion()

  var _m1$1 = new Matrix4()

  var _target = new Vector3()

  var _position = new Vector3()

  var _scale = new Vector3()

  var _quaternion$2 = new Quaternion()

  var _xAxis = new Vector3(1, 0, 0)

  var _yAxis = new Vector3(0, 1, 0)

  var _zAxis = new Vector3(0, 0, 1)

  var _addedEvent = {
    type: 'added'
  }
  var _removedEvent = {
    type: 'removed'
  }

  function Object3D() {
    Object.defineProperty(this, 'id', {
      value: _object3DId++
    })
    this.uuid = MathUtils.generateUUID()
    this.name = ''
    this.type = 'Object3D'
    this.parent = null
    this.children = []
    this.up = Object3D.DefaultUp.clone()
    var position = new Vector3()
    var rotation = new Euler()
    var quaternion = new Quaternion()
    var scale = new Vector3(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 Matrix4()
      },
      normalMatrix: {
        value: new Matrix3()
      }
    })
    this.matrix = new Matrix4()
    this.matrixWorld = new Matrix4()
    this.matrixAutoUpdate = Object3D.DefaultMatrixAutoUpdate
    this.matrixWorldNeedsUpdate = false
    this.layers = new Layers()
    this.visible = true
    this.castShadow = false
    this.receiveShadow = false
    this.frustumCulled = true
    this.renderOrder = 0
    this.animations = []
    this.userData = {}
  }

  Object3D.DefaultUp = new Vector3(0, 1, 0)
  Object3D.DefaultMatrixAutoUpdate = true
  Object3D.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Object3D,
    isObject3D: true,
    onBeforeRender: function onBeforeRender() {},
    onAfterRender: function onAfterRender() {},
    applyMatrix4: function applyMatrix4(matrix) {
      if (this.matrixAutoUpdate) this.updateMatrix()
      this.matrix.premultiply(matrix)
      this.matrix.decompose(this.position, this.quaternion, this.scale)
    },
    applyQuaternion: function applyQuaternion(q) {
      this.quaternion.premultiply(q)
      return this
    },
    setRotationFromAxisAngle: function setRotationFromAxisAngle(axis, angle) {
      // assumes axis is normalized
      this.quaternion.setFromAxisAngle(axis, angle)
    },
    setRotationFromEuler: function setRotationFromEuler(euler) {
      this.quaternion.setFromEuler(euler, true)
    },
    setRotationFromMatrix: function setRotationFromMatrix(m) {
      // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
      this.quaternion.setFromRotationMatrix(m)
    },
    setRotationFromQuaternion: function setRotationFromQuaternion(q) {
      // assumes q is normalized
      this.quaternion.copy(q)
    },
    rotateOnAxis: function rotateOnAxis(axis, angle) {
      // rotate object on axis in object space
      // axis is assumed to be normalized
      _q1.setFromAxisAngle(axis, angle)

      this.quaternion.multiply(_q1)
      return this
    },
    rotateOnWorldAxis: function rotateOnWorldAxis(axis, angle) {
      // rotate object on axis in world space
      // axis is assumed to be normalized
      // method assumes no rotated parent
      _q1.setFromAxisAngle(axis, angle)

      this.quaternion.premultiply(_q1)
      return this
    },
    rotateX: function rotateX(angle) {
      return this.rotateOnAxis(_xAxis, angle)
    },
    rotateY: function rotateY(angle) {
      return this.rotateOnAxis(_yAxis, angle)
    },
    rotateZ: function rotateZ(angle) {
      return this.rotateOnAxis(_zAxis, angle)
    },
    translateOnAxis: function translateOnAxis(axis, distance) {
      // translate object by distance along axis in object space
      // axis is assumed to be normalized
      _v1$2.copy(axis).applyQuaternion(this.quaternion)

      this.position.add(_v1$2.multiplyScalar(distance))
      return this
    },
    translateX: function translateX(distance) {
      return this.translateOnAxis(_xAxis, distance)
    },
    translateY: function translateY(distance) {
      return this.translateOnAxis(_yAxis, distance)
    },
    translateZ: function translateZ(distance) {
      return this.translateOnAxis(_zAxis, distance)
    },
    localToWorld: function localToWorld(vector) {
      return vector.applyMatrix4(this.matrixWorld)
    },
    worldToLocal: function worldToLocal(vector) {
      return vector.applyMatrix4(_m1$1.copy(this.matrixWorld).invert())
    },
    lookAt: function lookAt(x, y, z) {
      // This method does not support objects having non-uniformly-scaled parent(s)
      if (x.isVector3) {
        _target.copy(x)
      } else {
        _target.set(x, y, z)
      }

      var parent = this.parent
      this.updateWorldMatrix(true, false)

      _position.setFromMatrixPosition(this.matrixWorld)

      if (this.isCamera || this.isLight) {
        _m1$1.lookAt(_position, _target, this.up)
      } else {
        _m1$1.lookAt(_target, _position, this.up)
      }

      this.quaternion.setFromRotationMatrix(_m1$1)

      if (parent) {
        _m1$1.extractRotation(parent.matrixWorld)

        _q1.setFromRotationMatrix(_m1$1)

        this.quaternion.premultiply(_q1.invert())
      }
    },
    add: function add(object) {
      if (arguments.length > 1) {
        for (var 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) {
        if (object.parent !== null) {
          object.parent.remove(object)
        }

        object.parent = this
        this.children.push(object)
        object.dispatchEvent(_addedEvent)
      } else {
        console.error('THREE.Object3D.add: object not an instance of THREE.Object3D.', object)
      }

      return this
    },
    remove: function remove(object) {
      if (arguments.length > 1) {
        for (var i = 0; i < arguments.length; i++) {
          this.remove(arguments[i])
        }

        return this
      }

      var index = this.children.indexOf(object)

      if (index !== -1) {
        object.parent = null
        this.children.splice(index, 1)
        object.dispatchEvent(_removedEvent)
      }

      return this
    },
    clear: function clear() {
      for (var i = 0; i < this.children.length; i++) {
        var object = this.children[i]
        object.parent = null
        object.dispatchEvent(_removedEvent)
      }

      this.children.length = 0
      return this
    },
    attach: function attach(object) {
      // adds object as a child of this, while maintaining the object's world transform
      this.updateWorldMatrix(true, false)

      _m1$1.copy(this.matrixWorld).invert()

      if (object.parent !== null) {
        object.parent.updateWorldMatrix(true, false)

        _m1$1.multiply(object.parent.matrixWorld)
      }

      object.applyMatrix4(_m1$1)
      object.updateWorldMatrix(false, false)
      this.add(object)
      return this
    },
    getObjectById: function getObjectById(id) {
      return this.getObjectByProperty('id', id)
    },
    getObjectByName: function getObjectByName(name) {
      return this.getObjectByProperty('name', name)
    },
    getObjectByProperty: function getObjectByProperty(name, value) {
      if (this[name] === value) return this

      for (var i = 0, l = this.children.length; i < l; i++) {
        var child = this.children[i]
        var object = child.getObjectByProperty(name, value)

        if (object !== undefined) {
          return object
        }
      }

      return undefined
    },
    getWorldPosition: function getWorldPosition(target) {
      if (target === undefined) {
        console.warn('THREE.Object3D: .getWorldPosition() target is now required')
        target = new Vector3()
      }

      this.updateWorldMatrix(true, false)
      return target.setFromMatrixPosition(this.matrixWorld)
    },
    getWorldQuaternion: function getWorldQuaternion(target) {
      if (target === undefined) {
        console.warn('THREE.Object3D: .getWorldQuaternion() target is now required')
        target = new Quaternion()
      }

      this.updateWorldMatrix(true, false)
      this.matrixWorld.decompose(_position, target, _scale)
      return target
    },
    getWorldScale: function getWorldScale(target) {
      if (target === undefined) {
        console.warn('THREE.Object3D: .getWorldScale() target is now required')
        target = new Vector3()
      }

      this.updateWorldMatrix(true, false)
      this.matrixWorld.decompose(_position, _quaternion$2, target)
      return target
    },
    getWorldDirection: function getWorldDirection(target) {
      if (target === undefined) {
        console.warn('THREE.Object3D: .getWorldDirection() target is now required')
        target = new Vector3()
      }

      this.updateWorldMatrix(true, false)
      var e = this.matrixWorld.elements
      return target.set(e[8], e[9], e[10]).normalize()
    },
    raycast: function raycast() {},
    traverse: function traverse(callback) {
      callback(this)
      var children = this.children

      for (var i = 0, l = children.length; i < l; i++) {
        children[i].traverse(callback)
      }
    },
    traverseVisible: function traverseVisible(callback) {
      if (this.visible === false) return
      callback(this)
      var children = this.children

      for (var i = 0, l = children.length; i < l; i++) {
        children[i].traverseVisible(callback)
      }
    },
    traverseAncestors: function traverseAncestors(callback) {
      var parent = this.parent

      if (parent !== null) {
        callback(parent)
        parent.traverseAncestors(callback)
      }
    },
    updateMatrix: function updateMatrix() {
      this.matrix.compose(this.position, this.quaternion, this.scale)
      this.matrixWorldNeedsUpdate = true
    },
    updateMatrixWorld: function updateMatrixWorld(force) {
      if (this.matrixAutoUpdate) this.updateMatrix()

      if (this.matrixWorldNeedsUpdate || force) {
        if (this.parent === null) {
          this.matrixWorld.copy(this.matrix)
        } else {
          this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix)
        }

        this.matrixWorldNeedsUpdate = false
        force = true
      } // update children

      var children = this.children

      for (var i = 0, l = children.length; i < l; i++) {
        children[i].updateMatrixWorld(force)
      }
    },
    updateWorldMatrix: function updateWorldMatrix(updateParents, updateChildren) {
      var parent = this.parent

      if (updateParents === true && parent !== null) {
        parent.updateWorldMatrix(true, false)
      }

      if (this.matrixAutoUpdate) this.updateMatrix()

      if (this.parent === null) {
        this.matrixWorld.copy(this.matrix)
      } else {
        this.matrixWorld.multiplyMatrices(this.parent.matrixWorld, this.matrix)
      } // update children

      if (updateChildren === true) {
        var children = this.children

        for (var i = 0, l = children.length; i < l; i++) {
          children[i].updateWorldMatrix(false, true)
        }
      }
    },
    toJSON: function toJSON(meta) {
      // meta is a string when called from JSON.stringify
      var isRootObject = meta === undefined || typeof meta === 'string'
      var 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: {}
        }
        output.metadata = {
          version: 4.5,
          type: 'Object',
          generator: 'Object3D.toJSON'
        }
      } // standard Object3D serialization

      var 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 (JSON.stringify(this.userData) !== '{}') object.userData = this.userData
      object.layers = this.layers.mask
      object.matrix = this.matrix.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()
      } //

      function serialize(library, element) {
        if (library[element.uuid] === undefined) {
          library[element.uuid] = element.toJSON(meta)
        }

        return element.uuid
      }

      if (this.isMesh || this.isLine || this.isPoints) {
        object.geometry = serialize(meta.geometries, this.geometry)
        var parameters = this.geometry.parameters

        if (parameters !== undefined && parameters.shapes !== undefined) {
          var shapes = parameters.shapes

          if (Array.isArray(shapes)) {
            for (var i = 0, l = shapes.length; i < l; i++) {
              var 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)) {
          var uuids = []

          for (var _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 (var _i2 = 0; _i2 < this.children.length; _i2++) {
          object.children.push(this.children[_i2].toJSON(meta).object)
        }
      } //

      if (this.animations.length > 0) {
        object.animations = []

        for (var _i3 = 0; _i3 < this.animations.length; _i3++) {
          var animation = this.animations[_i3]
          object.animations.push(serialize(meta.animations, animation))
        }
      }

      if (isRootObject) {
        var geometries = extractFromCache(meta.geometries)
        var materials = extractFromCache(meta.materials)
        var textures = extractFromCache(meta.textures)
        var images = extractFromCache(meta.images)

        var _shapes = extractFromCache(meta.shapes)

        var skeletons = extractFromCache(meta.skeletons)
        var animations = extractFromCache(meta.animations)
        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
      }

      output.object = object
      return output // extract data from the cache hash
      // remove metadata on each item
      // and return as array

      function extractFromCache(cache) {
        var values = []

        for (var key in cache) {
          var data = cache[key]
          delete data.metadata
          values.push(data)
        }

        return values
      }
    },
    clone: function clone(recursive) {
      return new this.constructor().copy(this, recursive)
    },
    copy: function copy(source, recursive) {
      if (recursive === void 0) {
        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.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.userData = JSON.parse(JSON.stringify(source.userData))

      if (recursive === true) {
        for (var i = 0; i < source.children.length; i++) {
          var child = source.children[i]
          this.add(child.clone())
        }
      }

      return this
    }
  })

  var _vector1 = /*@__PURE__*/ new Vector3()

  var _vector2 = /*@__PURE__*/ new Vector3()

  var _normalMatrix = /*@__PURE__*/ new Matrix3()

  var Plane = /*#__PURE__*/ (function () {
    function Plane(normal, constant) {
      Object.defineProperty(this, 'isPlane', {
        value: true
      }) // normal is assumed to be normalized

      this.normal = normal !== undefined ? normal : new Vector3(1, 0, 0)
      this.constant = constant !== undefined ? constant : 0
    }

    var _proto = Plane.prototype

    _proto.set = function set(normal, constant) {
      this.normal.copy(normal)
      this.constant = constant
      return this
    }

    _proto.setComponents = function setComponents(x, y, z, w) {
      this.normal.set(x, y, z)
      this.constant = w
      return this
    }

    _proto.setFromNormalAndCoplanarPoint = function setFromNormalAndCoplanarPoint(normal, point) {
      this.normal.copy(normal)
      this.constant = -point.dot(this.normal)
      return this
    }

    _proto.setFromCoplanarPoints = function setFromCoplanarPoints(a, b, c) {
      var normal = _vector1.subVectors(c, b).cross(_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
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(plane) {
      this.normal.copy(plane.normal)
      this.constant = plane.constant
      return this
    }

    _proto.normalize = function normalize() {
      // Note: will lead to a divide by zero if the plane is invalid.
      var inverseNormalLength = 1.0 / this.normal.length()
      this.normal.multiplyScalar(inverseNormalLength)
      this.constant *= inverseNormalLength
      return this
    }

    _proto.negate = function negate() {
      this.constant *= -1
      this.normal.negate()
      return this
    }

    _proto.distanceToPoint = function distanceToPoint(point) {
      return this.normal.dot(point) + this.constant
    }

    _proto.distanceToSphere = function distanceToSphere(sphere) {
      return this.distanceToPoint(sphere.center) - sphere.radius
    }

    _proto.projectPoint = function projectPoint(point, target) {
      if (target === undefined) {
        console.warn('THREE.Plane: .projectPoint() target is now required')
        target = new Vector3()
      }

      return target.copy(this.normal).multiplyScalar(-this.distanceToPoint(point)).add(point)
    }

    _proto.intersectLine = function intersectLine(line, target) {
      if (target === undefined) {
        console.warn('THREE.Plane: .intersectLine() target is now required')
        target = new Vector3()
      }

      var direction = line.delta(_vector1)
      var 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 undefined
      }

      var t = -(line.start.dot(this.normal) + this.constant) / denominator

      if (t < 0 || t > 1) {
        return undefined
      }

      return target.copy(direction).multiplyScalar(t).add(line.start)
    }

    _proto.intersectsLine = function intersectsLine(line) {
      // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
      var startSign = this.distanceToPoint(line.start)
      var endSign = this.distanceToPoint(line.end)
      return (startSign < 0 && endSign > 0) || (endSign < 0 && startSign > 0)
    }

    _proto.intersectsBox = function intersectsBox(box) {
      return box.intersectsPlane(this)
    }

    _proto.intersectsSphere = function intersectsSphere(sphere) {
      return sphere.intersectsPlane(this)
    }

    _proto.coplanarPoint = function coplanarPoint(target) {
      if (target === undefined) {
        console.warn('THREE.Plane: .coplanarPoint() target is now required')
        target = new Vector3()
      }

      return target.copy(this.normal).multiplyScalar(-this.constant)
    }

    _proto.applyMatrix4 = function applyMatrix4(matrix, optionalNormalMatrix) {
      var normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix(matrix)

      var referencePoint = this.coplanarPoint(_vector1).applyMatrix4(matrix)
      var normal = this.normal.applyMatrix3(normalMatrix).normalize()
      this.constant = -referencePoint.dot(normal)
      return this
    }

    _proto.translate = function translate(offset) {
      this.constant -= offset.dot(this.normal)
      return this
    }

    _proto.equals = function equals(plane) {
      return plane.normal.equals(this.normal) && plane.constant === this.constant
    }

    return Plane
  })()

  var _v0$1 = /*@__PURE__*/ new Vector3()

  var _v1$3 = /*@__PURE__*/ new Vector3()

  var _v2$1 = /*@__PURE__*/ new Vector3()

  var _v3 = /*@__PURE__*/ new Vector3()

  var _vab = /*@__PURE__*/ new Vector3()

  var _vac = /*@__PURE__*/ new Vector3()

  var _vbc = /*@__PURE__*/ new Vector3()

  var _vap = /*@__PURE__*/ new Vector3()

  var _vbp = /*@__PURE__*/ new Vector3()

  var _vcp = /*@__PURE__*/ new Vector3()

  var Triangle = /*#__PURE__*/ (function () {
    function Triangle(a, b, c) {
      this.a = a !== undefined ? a : new Vector3()
      this.b = b !== undefined ? b : new Vector3()
      this.c = c !== undefined ? c : new Vector3()
    }

    Triangle.getNormal = function getNormal(a, b, c, target) {
      if (target === undefined) {
        console.warn('THREE.Triangle: .getNormal() target is now required')
        target = new Vector3()
      }

      target.subVectors(c, b)

      _v0$1.subVectors(a, b)

      target.cross(_v0$1)
      var 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

    Triangle.getBarycoord = function getBarycoord(point, a, b, c, target) {
      _v0$1.subVectors(c, a)

      _v1$3.subVectors(b, a)

      _v2$1.subVectors(point, a)

      var dot00 = _v0$1.dot(_v0$1)

      var dot01 = _v0$1.dot(_v1$3)

      var dot02 = _v0$1.dot(_v2$1)

      var dot11 = _v1$3.dot(_v1$3)

      var dot12 = _v1$3.dot(_v2$1)

      var denom = dot00 * dot11 - dot01 * dot01

      if (target === undefined) {
        console.warn('THREE.Triangle: .getBarycoord() target is now required')
        target = new Vector3()
      } // collinear or singular triangle

      if (denom === 0) {
        // arbitrary location outside of triangle?
        // not sure if this is the best idea, maybe should be returning undefined
        return target.set(-2, -1, -1)
      }

      var invDenom = 1 / denom
      var u = (dot11 * dot02 - dot01 * dot12) * invDenom
      var v = (dot00 * dot12 - dot01 * dot02) * invDenom // barycentric coordinates must always sum to 1

      return target.set(1 - u - v, v, u)
    }

    Triangle.containsPoint = function containsPoint(point, a, b, c) {
      this.getBarycoord(point, a, b, c, _v3)
      return _v3.x >= 0 && _v3.y >= 0 && _v3.x + _v3.y <= 1
    }

    Triangle.getUV = function getUV(point, p1, p2, p3, uv1, uv2, uv3, target) {
      this.getBarycoord(point, p1, p2, p3, _v3)
      target.set(0, 0)
      target.addScaledVector(uv1, _v3.x)
      target.addScaledVector(uv2, _v3.y)
      target.addScaledVector(uv3, _v3.z)
      return target
    }

    Triangle.isFrontFacing = function isFrontFacing(a, b, c, direction) {
      _v0$1.subVectors(c, b)

      _v1$3.subVectors(a, b) // strictly front facing

      return _v0$1.cross(_v1$3).dot(direction) < 0 ? true : false
    }

    var _proto = Triangle.prototype

    _proto.set = function set(a, b, c) {
      this.a.copy(a)
      this.b.copy(b)
      this.c.copy(c)
      return this
    }

    _proto.setFromPointsAndIndices = function setFromPointsAndIndices(points, i0, i1, i2) {
      this.a.copy(points[i0])
      this.b.copy(points[i1])
      this.c.copy(points[i2])
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(triangle) {
      this.a.copy(triangle.a)
      this.b.copy(triangle.b)
      this.c.copy(triangle.c)
      return this
    }

    _proto.getArea = function getArea() {
      _v0$1.subVectors(this.c, this.b)

      _v1$3.subVectors(this.a, this.b)

      return _v0$1.cross(_v1$3).length() * 0.5
    }

    _proto.getMidpoint = function getMidpoint(target) {
      if (target === undefined) {
        console.warn('THREE.Triangle: .getMidpoint() target is now required')
        target = new Vector3()
      }

      return target
        .addVectors(this.a, this.b)
        .add(this.c)
        .multiplyScalar(1 / 3)
    }

    _proto.getNormal = function getNormal(target) {
      return Triangle.getNormal(this.a, this.b, this.c, target)
    }

    _proto.getPlane = function getPlane(target) {
      if (target === undefined) {
        console.warn('THREE.Triangle: .getPlane() target is now required')
        target = new Plane()
      }

      return target.setFromCoplanarPoints(this.a, this.b, this.c)
    }

    _proto.getBarycoord = function getBarycoord(point, target) {
      return Triangle.getBarycoord(point, this.a, this.b, this.c, target)
    }

    _proto.getUV = function getUV(point, uv1, uv2, uv3, target) {
      return Triangle.getUV(point, this.a, this.b, this.c, uv1, uv2, uv3, target)
    }

    _proto.containsPoint = function containsPoint(point) {
      return Triangle.containsPoint(point, this.a, this.b, this.c)
    }

    _proto.isFrontFacing = function isFrontFacing(direction) {
      return Triangle.isFrontFacing(this.a, this.b, this.c, direction)
    }

    _proto.intersectsBox = function intersectsBox(box) {
      return box.intersectsTriangle(this)
    }

    _proto.closestPointToPoint = function closestPointToPoint(p, target) {
      if (target === undefined) {
        console.warn('THREE.Triangle: .closestPointToPoint() target is now required')
        target = new Vector3()
      }

      var a = this.a,
        b = this.b,
        c = this.c
      var 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.

      _vab.subVectors(b, a)

      _vac.subVectors(c, a)

      _vap.subVectors(p, a)

      var d1 = _vab.dot(_vap)

      var d2 = _vac.dot(_vap)

      if (d1 <= 0 && d2 <= 0) {
        // vertex region of A; barycentric coords (1, 0, 0)
        return target.copy(a)
      }

      _vbp.subVectors(p, b)

      var d3 = _vab.dot(_vbp)

      var d4 = _vac.dot(_vbp)

      if (d3 >= 0 && d4 <= d3) {
        // vertex region of B; barycentric coords (0, 1, 0)
        return target.copy(b)
      }

      var 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(_vab, v)
      }

      _vcp.subVectors(p, c)

      var d5 = _vab.dot(_vcp)

      var d6 = _vac.dot(_vcp)

      if (d6 >= 0 && d5 <= d6) {
        // vertex region of C; barycentric coords (0, 0, 1)
        return target.copy(c)
      }

      var 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(_vac, w)
      }

      var va = d3 * d6 - d5 * d4

      if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
        _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(_vbc, w) // edge region of BC
      } // face region

      var denom = 1 / (va + vb + vc) // u = va * denom

      v = vb * denom
      w = vc * denom
      return target.copy(a).addScaledVector(_vab, v).addScaledVector(_vac, w)
    }

    _proto.equals = function equals(triangle) {
      return triangle.a.equals(this.a) && triangle.b.equals(this.b) && triangle.c.equals(this.c)
    }

    return Triangle
  })()

  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
  }
  var _hslA = {
    h: 0,
    s: 0,
    l: 0
  }
  var _hslB = {
    h: 0,
    s: 0,
    l: 0
  }

  function 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 < 1 / 2) return q
    if (t < 2 / 3) return p + (q - p) * 6 * (2 / 3 - t)
    return p
  }

  function SRGBToLinear(c) {
    return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4)
  }

  function LinearToSRGB(c) {
    return c < 0.0031308 ? c * 12.92 : 1.055 * Math.pow(c, 0.41666) - 0.055
  }

  var Color = /*#__PURE__*/ (function () {
    function Color(r, g, b) {
      Object.defineProperty(this, 'isColor', {
        value: true
      })

      if (g === undefined && b === undefined) {
        // r is THREE.Color, hex or string
        return this.set(r)
      }

      return this.setRGB(r, g, b)
    }

    var _proto = Color.prototype

    _proto.set = function set(value) {
      if (value && value.isColor) {
        this.copy(value)
      } else if (typeof value === 'number') {
        this.setHex(value)
      } else if (typeof value === 'string') {
        this.setStyle(value)
      }

      return this
    }

    _proto.setScalar = function setScalar(scalar) {
      this.r = scalar
      this.g = scalar
      this.b = scalar
      return this
    }

    _proto.setHex = function setHex(hex) {
      hex = Math.floor(hex)
      this.r = ((hex >> 16) & 255) / 255
      this.g = ((hex >> 8) & 255) / 255
      this.b = (hex & 255) / 255
      return this
    }

    _proto.setRGB = function setRGB(r, g, b) {
      this.r = r
      this.g = g
      this.b = b
      return this
    }

    _proto.setHSL = function setHSL(h, s, l) {
      // h,s,l ranges are in 0.0 - 1.0
      h = MathUtils.euclideanModulo(h, 1)
      s = MathUtils.clamp(s, 0, 1)
      l = MathUtils.clamp(l, 0, 1)

      if (s === 0) {
        this.r = this.g = this.b = l
      } else {
        var p = l <= 0.5 ? l * (1 + s) : l + s - l * s
        var q = 2 * l - p
        this.r = hue2rgb(q, p, h + 1 / 3)
        this.g = hue2rgb(q, p, h)
        this.b = hue2rgb(q, p, h - 1 / 3)
      }

      return this
    }

    _proto.setStyle = function setStyle(style) {
      function handleAlpha(string) {
        if (string === undefined) return

        if (parseFloat(string) < 1) {
          console.warn('THREE.Color: Alpha component of ' + style + ' will be ignored.')
        }
      }

      var m

      if ((m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec(style))) {
        // rgb / hsl
        var color
        var name = m[1]
        var components = m[2]

        switch (name) {
          case 'rgb':
          case 'rgba':
            if ((color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(components))) {
              // rgb(255,0,0) rgba(255,0,0,0.5)
              this.r = Math.min(255, parseInt(color[1], 10)) / 255
              this.g = Math.min(255, parseInt(color[2], 10)) / 255
              this.b = Math.min(255, parseInt(color[3], 10)) / 255
              handleAlpha(color[5])
              return this
            }

            if ((color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(components))) {
              // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
              this.r = Math.min(100, parseInt(color[1], 10)) / 100
              this.g = Math.min(100, parseInt(color[2], 10)) / 100
              this.b = Math.min(100, parseInt(color[3], 10)) / 100
              handleAlpha(color[5])
              return this
            }

            break

          case 'hsl':
          case 'hsla':
            if ((color = /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec(components))) {
              // hsl(120,50%,50%) hsla(120,50%,50%,0.5)
              var h = parseFloat(color[1]) / 360
              var s = parseInt(color[2], 10) / 100
              var l = parseInt(color[3], 10) / 100
              handleAlpha(color[5])
              return this.setHSL(h, s, l)
            }

            break
        }
      } else if ((m = /^\#([A-Fa-f0-9]+)$/.exec(style))) {
        // hex color
        var hex = m[1]
        var size = hex.length

        if (size === 3) {
          // #ff0
          this.r = parseInt(hex.charAt(0) + hex.charAt(0), 16) / 255
          this.g = parseInt(hex.charAt(1) + hex.charAt(1), 16) / 255
          this.b = parseInt(hex.charAt(2) + hex.charAt(2), 16) / 255
          return this
        } else if (size === 6) {
          // #ff0000
          this.r = parseInt(hex.charAt(0) + hex.charAt(1), 16) / 255
          this.g = parseInt(hex.charAt(2) + hex.charAt(3), 16) / 255
          this.b = parseInt(hex.charAt(4) + hex.charAt(5), 16) / 255
          return this
        }
      }

      if (style && style.length > 0) {
        return this.setColorName(style)
      }

      return this
    }

    _proto.setColorName = function setColorName(style) {
      // color keywords
      var hex = _colorKeywords[style]

      if (hex !== undefined) {
        // red
        this.setHex(hex)
      } else {
        // unknown color
        console.warn('THREE.Color: Unknown color ' + style)
      }

      return this
    }

    _proto.clone = function clone() {
      return new this.constructor(this.r, this.g, this.b)
    }

    _proto.copy = function copy(color) {
      this.r = color.r
      this.g = color.g
      this.b = color.b
      return this
    }

    _proto.copyGammaToLinear = function copyGammaToLinear(color, gammaFactor) {
      if (gammaFactor === void 0) {
        gammaFactor = 2.0
      }

      this.r = Math.pow(color.r, gammaFactor)
      this.g = Math.pow(color.g, gammaFactor)
      this.b = Math.pow(color.b, gammaFactor)
      return this
    }

    _proto.copyLinearToGamma = function copyLinearToGamma(color, gammaFactor) {
      if (gammaFactor === void 0) {
        gammaFactor = 2.0
      }

      var safeInverse = gammaFactor > 0 ? 1.0 / gammaFactor : 1.0
      this.r = Math.pow(color.r, safeInverse)
      this.g = Math.pow(color.g, safeInverse)
      this.b = Math.pow(color.b, safeInverse)
      return this
    }

    _proto.convertGammaToLinear = function convertGammaToLinear(gammaFactor) {
      this.copyGammaToLinear(this, gammaFactor)
      return this
    }

    _proto.convertLinearToGamma = function convertLinearToGamma(gammaFactor) {
      this.copyLinearToGamma(this, gammaFactor)
      return this
    }

    _proto.copySRGBToLinear = function copySRGBToLinear(color) {
      this.r = SRGBToLinear(color.r)
      this.g = SRGBToLinear(color.g)
      this.b = SRGBToLinear(color.b)
      return this
    }

    _proto.copyLinearToSRGB = function copyLinearToSRGB(color) {
      this.r = LinearToSRGB(color.r)
      this.g = LinearToSRGB(color.g)
      this.b = LinearToSRGB(color.b)
      return this
    }

    _proto.convertSRGBToLinear = function convertSRGBToLinear() {
      this.copySRGBToLinear(this)
      return this
    }

    _proto.convertLinearToSRGB = function convertLinearToSRGB() {
      this.copyLinearToSRGB(this)
      return this
    }

    _proto.getHex = function getHex() {
      return ((this.r * 255) << 16) ^ ((this.g * 255) << 8) ^ ((this.b * 255) << 0)
    }

    _proto.getHexString = function getHexString() {
      return ('000000' + this.getHex().toString(16)).slice(-6)
    }

    _proto.getHSL = function getHSL(target) {
      // h,s,l ranges are in 0.0 - 1.0
      if (target === undefined) {
        console.warn('THREE.Color: .getHSL() target is now required')
        target = {
          h: 0,
          s: 0,
          l: 0
        }
      }

      var r = this.r,
        g = this.g,
        b = this.b
      var max = Math.max(r, g, b)
      var min = Math.min(r, g, b)
      var hue, saturation
      var lightness = (min + max) / 2.0

      if (min === max) {
        hue = 0
        saturation = 0
      } else {
        var 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
    }

    _proto.getStyle = function getStyle() {
      return 'rgb(' + ((this.r * 255) | 0) + ',' + ((this.g * 255) | 0) + ',' + ((this.b * 255) | 0) + ')'
    }

    _proto.offsetHSL = function offsetHSL(h, s, l) {
      this.getHSL(_hslA)
      _hslA.h += h
      _hslA.s += s
      _hslA.l += l
      this.setHSL(_hslA.h, _hslA.s, _hslA.l)
      return this
    }

    _proto.add = function add(color) {
      this.r += color.r
      this.g += color.g
      this.b += color.b
      return this
    }

    _proto.addColors = function addColors(color1, color2) {
      this.r = color1.r + color2.r
      this.g = color1.g + color2.g
      this.b = color1.b + color2.b
      return this
    }

    _proto.addScalar = function addScalar(s) {
      this.r += s
      this.g += s
      this.b += s
      return this
    }

    _proto.sub = function 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
    }

    _proto.multiply = function multiply(color) {
      this.r *= color.r
      this.g *= color.g
      this.b *= color.b
      return this
    }

    _proto.multiplyScalar = function multiplyScalar(s) {
      this.r *= s
      this.g *= s
      this.b *= s
      return this
    }

    _proto.lerp = function 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
    }

    _proto.lerpHSL = function lerpHSL(color, alpha) {
      this.getHSL(_hslA)
      color.getHSL(_hslB)
      var h = MathUtils.lerp(_hslA.h, _hslB.h, alpha)
      var s = MathUtils.lerp(_hslA.s, _hslB.s, alpha)
      var l = MathUtils.lerp(_hslA.l, _hslB.l, alpha)
      this.setHSL(h, s, l)
      return this
    }

    _proto.equals = function equals(c) {
      return c.r === this.r && c.g === this.g && c.b === this.b
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      this.r = array[offset]
      this.g = array[offset + 1]
      this.b = array[offset + 2]
      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      array[offset] = this.r
      array[offset + 1] = this.g
      array[offset + 2] = this.b
      return array
    }

    _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index) {
      this.r = attribute.getX(index)
      this.g = attribute.getY(index)
      this.b = attribute.getZ(index)

      if (attribute.normalized === true) {
        // assuming Uint8Array
        this.r /= 255
        this.g /= 255
        this.b /= 255
      }

      return this
    }

    _proto.toJSON = function toJSON() {
      return this.getHex()
    }

    return Color
  })()

  Color.NAMES = _colorKeywords
  Color.prototype.r = 1
  Color.prototype.g = 1
  Color.prototype.b = 1

  var Face3 = /*#__PURE__*/ (function () {
    function Face3(a, b, c, normal, color, materialIndex) {
      if (materialIndex === void 0) {
        materialIndex = 0
      }

      this.a = a
      this.b = b
      this.c = c
      this.normal = normal && normal.isVector3 ? normal : new Vector3()
      this.vertexNormals = Array.isArray(normal) ? normal : []
      this.color = color && color.isColor ? color : new Color()
      this.vertexColors = Array.isArray(color) ? color : []
      this.materialIndex = materialIndex
    }

    var _proto = Face3.prototype

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(source) {
      this.a = source.a
      this.b = source.b
      this.c = source.c
      this.normal.copy(source.normal)
      this.color.copy(source.color)
      this.materialIndex = source.materialIndex

      for (var i = 0, il = source.vertexNormals.length; i < il; i++) {
        this.vertexNormals[i] = source.vertexNormals[i].clone()
      }

      for (var _i = 0, _il = source.vertexColors.length; _i < _il; _i++) {
        this.vertexColors[_i] = source.vertexColors[_i].clone()
      }

      return this
    }

    return Face3
  })()

  var materialId = 0

  function Material() {
    Object.defineProperty(this, 'id', {
      value: materialId++
    })
    this.uuid = MathUtils.generateUUID()
    this.name = ''
    this.type = 'Material'
    this.fog = true
    this.blending = NormalBlending
    this.side = FrontSide
    this.flatShading = false
    this.vertexColors = false
    this.opacity = 1
    this.transparent = false
    this.blendSrc = SrcAlphaFactor
    this.blendDst = OneMinusSrcAlphaFactor
    this.blendEquation = AddEquation
    this.blendSrcAlpha = null
    this.blendDstAlpha = null
    this.blendEquationAlpha = null
    this.depthFunc = LessEqualDepth
    this.depthTest = true
    this.depthWrite = true
    this.stencilWriteMask = 0xff
    this.stencilFunc = AlwaysStencilFunc
    this.stencilRef = 0
    this.stencilFuncMask = 0xff
    this.stencilFail = KeepStencilOp
    this.stencilZFail = KeepStencilOp
    this.stencilZPass = KeepStencilOp
    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.alphaTest = 0
    this.premultipliedAlpha = false
    this.visible = true
    this.toneMapped = true
    this.userData = {}
    this.version = 0
  }

  Material.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Material,
    isMaterial: true,
    onBeforeCompile: function onBeforeCompile() /* shaderobject, renderer */
    {},
    customProgramCacheKey: function customProgramCacheKey() {
      return this.onBeforeCompile.toString()
    },
    setValues: function setValues(values) {
      if (values === undefined) return

      for (var key in values) {
        var newValue = values[key]

        if (newValue === undefined) {
          console.warn("THREE.Material: '" + key + "' parameter is undefined.")
          continue
        } // for backward compatability if shading is set in the constructor

        if (key === 'shading') {
          console.warn('THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.')
          this.flatShading = newValue === FlatShading ? true : false
          continue
        }

        var currentValue = this[key]

        if (currentValue === undefined) {
          console.warn('THREE.' + this.type + ": '" + key + "' is not a property of this material.")
          continue
        }

        if (currentValue && currentValue.isColor) {
          currentValue.set(newValue)
        } else if (currentValue && currentValue.isVector3 && newValue && newValue.isVector3) {
          currentValue.copy(newValue)
        } else {
          this[key] = newValue
        }
      }
    },
    toJSON: function toJSON(meta) {
      var isRoot = meta === undefined || typeof meta === 'string'

      if (isRoot) {
        meta = {
          textures: {},
          images: {}
        }
      }

      var data = {
        metadata: {
          version: 4.5,
          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 && this.sheen.isColor) data.sheen = this.sheen.getHex()
      if (this.emissive && this.emissive.isColor) data.emissive = this.emissive.getHex()
      if (this.emissiveIntensity && this.emissiveIntensity !== 1) data.emissiveIntensity = this.emissiveIntensity
      if (this.specular && this.specular.isColor) data.specular = this.specular.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.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

      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.envMap && this.envMap.isTexture) {
        data.envMap = this.envMap.toJSON(meta).uuid
        data.reflectivity = this.reflectivity // Scale behind envMap

        data.refractionRatio = this.refractionRatio
        if (this.combine !== undefined) data.combine = this.combine
        if (this.envMapIntensity !== undefined) data.envMapIntensity = this.envMapIntensity
      }

      if (this.gradientMap && this.gradientMap.isTexture) {
        data.gradientMap = this.gradientMap.toJSON(meta).uuid
      }

      if (this.size !== undefined) data.size = this.size
      if (this.sizeAttenuation !== undefined) data.sizeAttenuation = this.sizeAttenuation
      if (this.blending !== NormalBlending) data.blending = this.blending
      if (this.flatShading === true) data.flatShading = this.flatShading
      if (this.side !== FrontSide) data.side = this.side
      if (this.vertexColors) data.vertexColors = true
      if (this.opacity < 1) data.opacity = this.opacity
      if (this.transparent === true) data.transparent = this.transparent
      data.depthFunc = this.depthFunc
      data.depthTest = this.depthTest
      data.depthWrite = this.depthWrite
      data.stencilWrite = this.stencilWrite
      data.stencilWriteMask = this.stencilWriteMask
      data.stencilFunc = this.stencilFunc
      data.stencilRef = this.stencilRef
      data.stencilFuncMask = this.stencilFuncMask
      data.stencilFail = this.stencilFail
      data.stencilZFail = this.stencilZFail
      data.stencilZPass = this.stencilZPass // rotation (SpriteMaterial)

      if (this.rotation && 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 && 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.premultipliedAlpha === true) data.premultipliedAlpha = this.premultipliedAlpha
      if (this.wireframe === true) data.wireframe = this.wireframe
      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.morphTargets === true) data.morphTargets = true
      if (this.morphNormals === true) data.morphNormals = true
      if (this.skinning === true) data.skinning = true
      if (this.visible === false) data.visible = false
      if (this.toneMapped === false) data.toneMapped = false
      if (JSON.stringify(this.userData) !== '{}') data.userData = this.userData // TODO: Copied from Object3D.toJSON

      function extractFromCache(cache) {
        var values = []

        for (var key in cache) {
          var _data = cache[key]
          delete _data.metadata
          values.push(_data)
        }

        return values
      }

      if (isRoot) {
        var textures = extractFromCache(meta.textures)
        var images = extractFromCache(meta.images)
        if (textures.length > 0) data.textures = textures
        if (images.length > 0) data.images = images
      }

      return data
    },
    clone: function clone() {
      return new this.constructor().copy(this)
    },
    copy: function copy(source) {
      this.name = source.name
      this.fog = source.fog
      this.blending = source.blending
      this.side = source.side
      this.flatShading = source.flatShading
      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.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
      var srcPlanes = source.clippingPlanes
      var dstPlanes = null

      if (srcPlanes !== null) {
        var n = srcPlanes.length
        dstPlanes = new Array(n)

        for (var 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.premultipliedAlpha = source.premultipliedAlpha
      this.visible = source.visible
      this.toneMapped = source.toneMapped
      this.userData = JSON.parse(JSON.stringify(source.userData))
      return this
    },
    dispose: function dispose() {
      this.dispatchEvent({
        type: 'dispose'
      })
    }
  })
  Object.defineProperty(Material.prototype, 'needsUpdate', {
    set: function set(value) {
      if (value === true) this.version++
    }
  })

  /**
   * parameters = {
   *	color: <hex>,
   *	opacity: <float>,
   *	map: new THREE.Texture( <Image> ),
   *
   *	lightMap: new THREE.Texture( <Image> ),
   *	lightMapIntensity: <float>
   *
   *	aoMap: new THREE.Texture( <Image> ),
   *	aoMapIntensity: <float>
   *
   *	specularMap: new THREE.Texture( <Image> ),
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
   *	combine: THREE.Multiply,
   *	reflectivity: <float>,
   *	refractionRatio: <float>,
   *
   *	depthTest: <bool>,
   *	depthWrite: <bool>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>
   * }
   */

  function MeshBasicMaterial(parameters) {
    Material.call(this)
    this.type = 'MeshBasicMaterial'
    this.color = new Color(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.combine = MultiplyOperation
    this.reflectivity = 1
    this.refractionRatio = 0.98
    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'
    this.skinning = false
    this.morphTargets = false
    this.setValues(parameters)
  }

  MeshBasicMaterial.prototype = Object.create(Material.prototype)
  MeshBasicMaterial.prototype.constructor = MeshBasicMaterial
  MeshBasicMaterial.prototype.isMeshBasicMaterial = true

  MeshBasicMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.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.skinning = source.skinning
    this.morphTargets = source.morphTargets
    return this
  }

  var _vector$3 = new Vector3()

  var _vector2$1 = new Vector2()

  function BufferAttribute(array, itemSize, normalized) {
    if (Array.isArray(array)) {
      throw new TypeError('THREE.BufferAttribute: array should be a Typed Array.')
    }

    this.name = ''
    this.array = array
    this.itemSize = itemSize
    this.count = array !== undefined ? array.length / itemSize : 0
    this.normalized = normalized === true
    this.usage = StaticDrawUsage
    this.updateRange = {
      offset: 0,
      count: -1
    }
    this.version = 0
  }

  Object.defineProperty(BufferAttribute.prototype, 'needsUpdate', {
    set: function set(value) {
      if (value === true) this.version++
    }
  })
  Object.assign(BufferAttribute.prototype, {
    isBufferAttribute: true,
    onUploadCallback: function onUploadCallback() {},
    setUsage: function setUsage(value) {
      this.usage = value
      return this
    },
    copy: function 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
      return this
    },
    copyAt: function copyAt(index1, attribute, index2) {
      index1 *= this.itemSize
      index2 *= attribute.itemSize

      for (var i = 0, l = this.itemSize; i < l; i++) {
        this.array[index1 + i] = attribute.array[index2 + i]
      }

      return this
    },
    copyArray: function copyArray(array) {
      this.array.set(array)
      return this
    },
    copyColorsArray: function copyColorsArray(colors) {
      var array = this.array
      var offset = 0

      for (var i = 0, l = colors.length; i < l; i++) {
        var color = colors[i]

        if (color === undefined) {
          console.warn('THREE.BufferAttribute.copyColorsArray(): color is undefined', i)
          color = new Color()
        }

        array[offset++] = color.r
        array[offset++] = color.g
        array[offset++] = color.b
      }

      return this
    },
    copyVector2sArray: function copyVector2sArray(vectors) {
      var array = this.array
      var offset = 0

      for (var i = 0, l = vectors.length; i < l; i++) {
        var vector = vectors[i]

        if (vector === undefined) {
          console.warn('THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i)
          vector = new Vector2()
        }

        array[offset++] = vector.x
        array[offset++] = vector.y
      }

      return this
    },
    copyVector3sArray: function copyVector3sArray(vectors) {
      var array = this.array
      var offset = 0

      for (var i = 0, l = vectors.length; i < l; i++) {
        var vector = vectors[i]

        if (vector === undefined) {
          console.warn('THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i)
          vector = new Vector3()
        }

        array[offset++] = vector.x
        array[offset++] = vector.y
        array[offset++] = vector.z
      }

      return this
    },
    copyVector4sArray: function copyVector4sArray(vectors) {
      var array = this.array
      var offset = 0

      for (var i = 0, l = vectors.length; i < l; i++) {
        var vector = vectors[i]

        if (vector === undefined) {
          console.warn('THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i)
          vector = new Vector4()
        }

        array[offset++] = vector.x
        array[offset++] = vector.y
        array[offset++] = vector.z
        array[offset++] = vector.w
      }

      return this
    },
    applyMatrix3: function applyMatrix3(m) {
      if (this.itemSize === 2) {
        for (var i = 0, l = this.count; i < l; i++) {
          _vector2$1.fromBufferAttribute(this, i)

          _vector2$1.applyMatrix3(m)

          this.setXY(i, _vector2$1.x, _vector2$1.y)
        }
      } else if (this.itemSize === 3) {
        for (var _i = 0, _l = this.count; _i < _l; _i++) {
          _vector$3.fromBufferAttribute(this, _i)

          _vector$3.applyMatrix3(m)

          this.setXYZ(_i, _vector$3.x, _vector$3.y, _vector$3.z)
        }
      }

      return this
    },
    applyMatrix4: function applyMatrix4(m) {
      for (var i = 0, l = this.count; i < l; i++) {
        _vector$3.x = this.getX(i)
        _vector$3.y = this.getY(i)
        _vector$3.z = this.getZ(i)

        _vector$3.applyMatrix4(m)

        this.setXYZ(i, _vector$3.x, _vector$3.y, _vector$3.z)
      }

      return this
    },
    applyNormalMatrix: function applyNormalMatrix(m) {
      for (var i = 0, l = this.count; i < l; i++) {
        _vector$3.x = this.getX(i)
        _vector$3.y = this.getY(i)
        _vector$3.z = this.getZ(i)

        _vector$3.applyNormalMatrix(m)

        this.setXYZ(i, _vector$3.x, _vector$3.y, _vector$3.z)
      }

      return this
    },
    transformDirection: function transformDirection(m) {
      for (var i = 0, l = this.count; i < l; i++) {
        _vector$3.x = this.getX(i)
        _vector$3.y = this.getY(i)
        _vector$3.z = this.getZ(i)

        _vector$3.transformDirection(m)

        this.setXYZ(i, _vector$3.x, _vector$3.y, _vector$3.z)
      }

      return this
    },
    set: function set(value, offset) {
      if (offset === void 0) {
        offset = 0
      }

      this.array.set(value, offset)
      return this
    },
    getX: function getX(index) {
      return this.array[index * this.itemSize]
    },
    setX: function setX(index, x) {
      this.array[index * this.itemSize] = x
      return this
    },
    getY: function getY(index) {
      return this.array[index * this.itemSize + 1]
    },
    setY: function setY(index, y) {
      this.array[index * this.itemSize + 1] = y
      return this
    },
    getZ: function getZ(index) {
      return this.array[index * this.itemSize + 2]
    },
    setZ: function setZ(index, z) {
      this.array[index * this.itemSize + 2] = z
      return this
    },
    getW: function getW(index) {
      return this.array[index * this.itemSize + 3]
    },
    setW: function setW(index, w) {
      this.array[index * this.itemSize + 3] = w
      return this
    },
    setXY: function setXY(index, x, y) {
      index *= this.itemSize
      this.array[index + 0] = x
      this.array[index + 1] = y
      return this
    },
    setXYZ: function setXYZ(index, x, y, z) {
      index *= this.itemSize
      this.array[index + 0] = x
      this.array[index + 1] = y
      this.array[index + 2] = z
      return this
    },
    setXYZW: function setXYZW(index, x, y, z, w) {
      index *= this.itemSize
      this.array[index + 0] = x
      this.array[index + 1] = y
      this.array[index + 2] = z
      this.array[index + 3] = w
      return this
    },
    onUpload: function onUpload(callback) {
      this.onUploadCallback = callback
      return this
    },
    clone: function clone() {
      return new this.constructor(this.array, this.itemSize).copy(this)
    },
    toJSON: function toJSON() {
      return {
        itemSize: this.itemSize,
        type: this.array.constructor.name,
        array: Array.prototype.slice.call(this.array),
        normalized: this.normalized
      }
    }
  }) //

  function Int8BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Int8Array(array), itemSize, normalized)
  }

  Int8BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Int8BufferAttribute.prototype.constructor = Int8BufferAttribute

  function Uint8BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint8Array(array), itemSize, normalized)
  }

  Uint8BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint8BufferAttribute.prototype.constructor = Uint8BufferAttribute

  function Uint8ClampedBufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint8ClampedArray(array), itemSize, normalized)
  }

  Uint8ClampedBufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute

  function Int16BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Int16Array(array), itemSize, normalized)
  }

  Int16BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Int16BufferAttribute.prototype.constructor = Int16BufferAttribute

  function Uint16BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint16Array(array), itemSize, normalized)
  }

  Uint16BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint16BufferAttribute.prototype.constructor = Uint16BufferAttribute

  function Int32BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Int32Array(array), itemSize, normalized)
  }

  Int32BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Int32BufferAttribute.prototype.constructor = Int32BufferAttribute

  function Uint32BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint32Array(array), itemSize, normalized)
  }

  Uint32BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Uint32BufferAttribute.prototype.constructor = Uint32BufferAttribute

  function Float16BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Uint16Array(array), itemSize, normalized)
  }

  Float16BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Float16BufferAttribute.prototype.constructor = Float16BufferAttribute
  Float16BufferAttribute.prototype.isFloat16BufferAttribute = true

  function Float32BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Float32Array(array), itemSize, normalized)
  }

  Float32BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Float32BufferAttribute.prototype.constructor = Float32BufferAttribute

  function Float64BufferAttribute(array, itemSize, normalized) {
    BufferAttribute.call(this, new Float64Array(array), itemSize, normalized)
  }

  Float64BufferAttribute.prototype = Object.create(BufferAttribute.prototype)
  Float64BufferAttribute.prototype.constructor = Float64BufferAttribute //

  var DirectGeometry = /*#__PURE__*/ (function () {
    function DirectGeometry() {
      this.vertices = []
      this.normals = []
      this.colors = []
      this.uvs = []
      this.uvs2 = []
      this.groups = []
      this.morphTargets = {}
      this.skinWeights = []
      this.skinIndices = [] // this.lineDistances = [];

      this.boundingBox = null
      this.boundingSphere = null // update flags

      this.verticesNeedUpdate = false
      this.normalsNeedUpdate = false
      this.colorsNeedUpdate = false
      this.uvsNeedUpdate = false
      this.groupsNeedUpdate = false
    }

    var _proto = DirectGeometry.prototype

    _proto.computeGroups = function computeGroups(geometry) {
      var groups = []
      var group, i
      var materialIndex = undefined
      var faces = geometry.faces

      for (i = 0; i < faces.length; i++) {
        var face = faces[i] // materials

        if (face.materialIndex !== materialIndex) {
          materialIndex = face.materialIndex

          if (group !== undefined) {
            group.count = i * 3 - group.start
            groups.push(group)
          }

          group = {
            start: i * 3,
            materialIndex: materialIndex
          }
        }
      }

      if (group !== undefined) {
        group.count = i * 3 - group.start
        groups.push(group)
      }

      this.groups = groups
    }

    _proto.fromGeometry = function fromGeometry(geometry) {
      var faces = geometry.faces
      var vertices = geometry.vertices
      var faceVertexUvs = geometry.faceVertexUvs
      var hasFaceVertexUv = faceVertexUvs[0] && faceVertexUvs[0].length > 0
      var hasFaceVertexUv2 = faceVertexUvs[1] && faceVertexUvs[1].length > 0 // morphs

      var morphTargets = geometry.morphTargets
      var morphTargetsLength = morphTargets.length
      var morphTargetsPosition

      if (morphTargetsLength > 0) {
        morphTargetsPosition = []

        for (var i = 0; i < morphTargetsLength; i++) {
          morphTargetsPosition[i] = {
            name: morphTargets[i].name,
            data: []
          }
        }

        this.morphTargets.position = morphTargetsPosition
      }

      var morphNormals = geometry.morphNormals
      var morphNormalsLength = morphNormals.length
      var morphTargetsNormal

      if (morphNormalsLength > 0) {
        morphTargetsNormal = []

        for (var _i = 0; _i < morphNormalsLength; _i++) {
          morphTargetsNormal[_i] = {
            name: morphNormals[_i].name,
            data: []
          }
        }

        this.morphTargets.normal = morphTargetsNormal
      } // skins

      var skinIndices = geometry.skinIndices
      var skinWeights = geometry.skinWeights
      var hasSkinIndices = skinIndices.length === vertices.length
      var hasSkinWeights = skinWeights.length === vertices.length //

      if (vertices.length > 0 && faces.length === 0) {
        console.error('THREE.DirectGeometry: Faceless geometries are not supported.')
      }

      for (var _i2 = 0; _i2 < faces.length; _i2++) {
        var face = faces[_i2]
        this.vertices.push(vertices[face.a], vertices[face.b], vertices[face.c])
        var vertexNormals = face.vertexNormals

        if (vertexNormals.length === 3) {
          this.normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2])
        } else {
          var normal = face.normal
          this.normals.push(normal, normal, normal)
        }

        var vertexColors = face.vertexColors

        if (vertexColors.length === 3) {
          this.colors.push(vertexColors[0], vertexColors[1], vertexColors[2])
        } else {
          var color = face.color
          this.colors.push(color, color, color)
        }

        if (hasFaceVertexUv === true) {
          var vertexUvs = faceVertexUvs[0][_i2]

          if (vertexUvs !== undefined) {
            this.uvs.push(vertexUvs[0], vertexUvs[1], vertexUvs[2])
          } else {
            console.warn('THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', _i2)
            this.uvs.push(new Vector2(), new Vector2(), new Vector2())
          }
        }

        if (hasFaceVertexUv2 === true) {
          var _vertexUvs = faceVertexUvs[1][_i2]

          if (_vertexUvs !== undefined) {
            this.uvs2.push(_vertexUvs[0], _vertexUvs[1], _vertexUvs[2])
          } else {
            console.warn('THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', _i2)
            this.uvs2.push(new Vector2(), new Vector2(), new Vector2())
          }
        } // morphs

        for (var j = 0; j < morphTargetsLength; j++) {
          var morphTarget = morphTargets[j].vertices
          morphTargetsPosition[j].data.push(morphTarget[face.a], morphTarget[face.b], morphTarget[face.c])
        }

        for (var _j = 0; _j < morphNormalsLength; _j++) {
          var morphNormal = morphNormals[_j].vertexNormals[_i2]

          morphTargetsNormal[_j].data.push(morphNormal.a, morphNormal.b, morphNormal.c)
        } // skins

        if (hasSkinIndices) {
          this.skinIndices.push(skinIndices[face.a], skinIndices[face.b], skinIndices[face.c])
        }

        if (hasSkinWeights) {
          this.skinWeights.push(skinWeights[face.a], skinWeights[face.b], skinWeights[face.c])
        }
      }

      this.computeGroups(geometry)
      this.verticesNeedUpdate = geometry.verticesNeedUpdate
      this.normalsNeedUpdate = geometry.normalsNeedUpdate
      this.colorsNeedUpdate = geometry.colorsNeedUpdate
      this.uvsNeedUpdate = geometry.uvsNeedUpdate
      this.groupsNeedUpdate = geometry.groupsNeedUpdate

      if (geometry.boundingSphere !== null) {
        this.boundingSphere = geometry.boundingSphere.clone()
      }

      if (geometry.boundingBox !== null) {
        this.boundingBox = geometry.boundingBox.clone()
      }

      return this
    }

    return DirectGeometry
  })()

  function arrayMax(array) {
    if (array.length === 0) return -Infinity
    var max = array[0]

    for (var i = 1, l = array.length; i < l; ++i) {
      if (array[i] > max) max = array[i]
    }

    return max
  }

  var TYPED_ARRAYS = {
    Int8Array: Int8Array,
    Uint8Array: Uint8Array,
    // Workaround for IE11 pre KB2929437. See #11440
    Uint8ClampedArray: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : Uint8Array,
    Int16Array: Int16Array,
    Uint16Array: Uint16Array,
    Int32Array: Int32Array,
    Uint32Array: Uint32Array,
    Float32Array: Float32Array,
    Float64Array: Float64Array
  }

  function getTypedArray(type, buffer) {
    return new TYPED_ARRAYS[type](buffer)
  }

  var _bufferGeometryId = 1 // BufferGeometry uses odd numbers as Id

  var _m1$2 = new Matrix4()

  var _obj = new Object3D()

  var _offset = new Vector3()

  var _box$2 = new Box3()

  var _boxMorphTargets = new Box3()

  var _vector$4 = new Vector3()

  function BufferGeometry() {
    Object.defineProperty(this, 'id', {
      value: (_bufferGeometryId += 2)
    })
    this.uuid = MathUtils.generateUUID()
    this.name = ''
    this.type = 'BufferGeometry'
    this.index = null
    this.attributes = {}
    this.morphAttributes = {}
    this.morphTargetsRelative = false
    this.groups = []
    this.boundingBox = null
    this.boundingSphere = null
    this.drawRange = {
      start: 0,
      count: Infinity
    }
    this.userData = {}
  }

  BufferGeometry.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: BufferGeometry,
    isBufferGeometry: true,
    getIndex: function getIndex() {
      return this.index
    },
    setIndex: function setIndex(index) {
      if (Array.isArray(index)) {
        this.index = new (arrayMax(index) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute)(index, 1)
      } else {
        this.index = index
      }

      return this
    },
    getAttribute: function getAttribute(name) {
      return this.attributes[name]
    },
    setAttribute: function setAttribute(name, attribute) {
      this.attributes[name] = attribute
      return this
    },
    deleteAttribute: function deleteAttribute(name) {
      delete this.attributes[name]
      return this
    },
    hasAttribute: function hasAttribute(name) {
      return this.attributes[name] !== undefined
    },
    addGroup: function addGroup(start, count, materialIndex) {
      if (materialIndex === void 0) {
        materialIndex = 0
      }

      this.groups.push({
        start: start,
        count: count,
        materialIndex: materialIndex
      })
    },
    clearGroups: function clearGroups() {
      this.groups = []
    },
    setDrawRange: function setDrawRange(start, count) {
      this.drawRange.start = start
      this.drawRange.count = count
    },
    applyMatrix4: function applyMatrix4(matrix) {
      var position = this.attributes.position

      if (position !== undefined) {
        position.applyMatrix4(matrix)
        position.needsUpdate = true
      }

      var normal = this.attributes.normal

      if (normal !== undefined) {
        var normalMatrix = new Matrix3().getNormalMatrix(matrix)
        normal.applyNormalMatrix(normalMatrix)
        normal.needsUpdate = true
      }

      var 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
    },
    rotateX: function rotateX(angle) {
      // rotate geometry around world x-axis
      _m1$2.makeRotationX(angle)

      this.applyMatrix4(_m1$2)
      return this
    },
    rotateY: function rotateY(angle) {
      // rotate geometry around world y-axis
      _m1$2.makeRotationY(angle)

      this.applyMatrix4(_m1$2)
      return this
    },
    rotateZ: function rotateZ(angle) {
      // rotate geometry around world z-axis
      _m1$2.makeRotationZ(angle)

      this.applyMatrix4(_m1$2)
      return this
    },
    translate: function translate(x, y, z) {
      // translate geometry
      _m1$2.makeTranslation(x, y, z)

      this.applyMatrix4(_m1$2)
      return this
    },
    scale: function scale(x, y, z) {
      // scale geometry
      _m1$2.makeScale(x, y, z)

      this.applyMatrix4(_m1$2)
      return this
    },
    lookAt: function lookAt(vector) {
      _obj.lookAt(vector)

      _obj.updateMatrix()

      this.applyMatrix4(_obj.matrix)
      return this
    },
    center: function center() {
      this.computeBoundingBox()
      this.boundingBox.getCenter(_offset).negate()
      this.translate(_offset.x, _offset.y, _offset.z)
      return this
    },
    setFromObject: function setFromObject(object) {
      // console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );
      var geometry = object.geometry

      if (object.isPoints || object.isLine) {
        var positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3)
        var colors = new Float32BufferAttribute(geometry.colors.length * 3, 3)
        this.setAttribute('position', positions.copyVector3sArray(geometry.vertices))
        this.setAttribute('color', colors.copyColorsArray(geometry.colors))

        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
          var lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1)
          this.setAttribute('lineDistance', lineDistances.copyArray(geometry.lineDistances))
        }

        if (geometry.boundingSphere !== null) {
          this.boundingSphere = geometry.boundingSphere.clone()
        }

        if (geometry.boundingBox !== null) {
          this.boundingBox = geometry.boundingBox.clone()
        }
      } else if (object.isMesh) {
        if (geometry && geometry.isGeometry) {
          this.fromGeometry(geometry)
        }
      }

      return this
    },
    setFromPoints: function setFromPoints(points) {
      var position = []

      for (var i = 0, l = points.length; i < l; i++) {
        var point = points[i]
        position.push(point.x, point.y, point.z || 0)
      }

      this.setAttribute('position', new Float32BufferAttribute(position, 3))
      return this
    },
    updateFromObject: function updateFromObject(object) {
      var geometry = object.geometry

      if (object.isMesh) {
        var direct = geometry.__directGeometry

        if (geometry.elementsNeedUpdate === true) {
          direct = undefined
          geometry.elementsNeedUpdate = false
        }

        if (direct === undefined) {
          return this.fromGeometry(geometry)
        }

        direct.verticesNeedUpdate = geometry.verticesNeedUpdate
        direct.normalsNeedUpdate = geometry.normalsNeedUpdate
        direct.colorsNeedUpdate = geometry.colorsNeedUpdate
        direct.uvsNeedUpdate = geometry.uvsNeedUpdate
        direct.groupsNeedUpdate = geometry.groupsNeedUpdate
        geometry.verticesNeedUpdate = false
        geometry.normalsNeedUpdate = false
        geometry.colorsNeedUpdate = false
        geometry.uvsNeedUpdate = false
        geometry.groupsNeedUpdate = false
        geometry = direct
      }

      if (geometry.verticesNeedUpdate === true) {
        var attribute = this.attributes.position

        if (attribute !== undefined) {
          attribute.copyVector3sArray(geometry.vertices)
          attribute.needsUpdate = true
        }

        geometry.verticesNeedUpdate = false
      }

      if (geometry.normalsNeedUpdate === true) {
        var _attribute = this.attributes.normal

        if (_attribute !== undefined) {
          _attribute.copyVector3sArray(geometry.normals)

          _attribute.needsUpdate = true
        }

        geometry.normalsNeedUpdate = false
      }

      if (geometry.colorsNeedUpdate === true) {
        var _attribute2 = this.attributes.color

        if (_attribute2 !== undefined) {
          _attribute2.copyColorsArray(geometry.colors)

          _attribute2.needsUpdate = true
        }

        geometry.colorsNeedUpdate = false
      }

      if (geometry.uvsNeedUpdate) {
        var _attribute3 = this.attributes.uv

        if (_attribute3 !== undefined) {
          _attribute3.copyVector2sArray(geometry.uvs)

          _attribute3.needsUpdate = true
        }

        geometry.uvsNeedUpdate = false
      }

      if (geometry.lineDistancesNeedUpdate) {
        var _attribute4 = this.attributes.lineDistance

        if (_attribute4 !== undefined) {
          _attribute4.copyArray(geometry.lineDistances)

          _attribute4.needsUpdate = true
        }

        geometry.lineDistancesNeedUpdate = false
      }

      if (geometry.groupsNeedUpdate) {
        geometry.computeGroups(object.geometry)
        this.groups = geometry.groups
        geometry.groupsNeedUpdate = false
      }

      return this
    },
    fromGeometry: function fromGeometry(geometry) {
      geometry.__directGeometry = new DirectGeometry().fromGeometry(geometry)
      return this.fromDirectGeometry(geometry.__directGeometry)
    },
    fromDirectGeometry: function fromDirectGeometry(geometry) {
      var positions = new Float32Array(geometry.vertices.length * 3)
      this.setAttribute('position', new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices))

      if (geometry.normals.length > 0) {
        var normals = new Float32Array(geometry.normals.length * 3)
        this.setAttribute('normal', new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals))
      }

      if (geometry.colors.length > 0) {
        var colors = new Float32Array(geometry.colors.length * 3)
        this.setAttribute('color', new BufferAttribute(colors, 3).copyColorsArray(geometry.colors))
      }

      if (geometry.uvs.length > 0) {
        var uvs = new Float32Array(geometry.uvs.length * 2)
        this.setAttribute('uv', new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs))
      }

      if (geometry.uvs2.length > 0) {
        var uvs2 = new Float32Array(geometry.uvs2.length * 2)
        this.setAttribute('uv2', new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2))
      } // groups

      this.groups = geometry.groups // morphs

      for (var name in geometry.morphTargets) {
        var array = []
        var morphTargets = geometry.morphTargets[name]

        for (var i = 0, l = morphTargets.length; i < l; i++) {
          var morphTarget = morphTargets[i]
          var attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3)
          attribute.name = morphTarget.name
          array.push(attribute.copyVector3sArray(morphTarget.data))
        }

        this.morphAttributes[name] = array
      } // skinning

      if (geometry.skinIndices.length > 0) {
        var skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4)
        this.setAttribute('skinIndex', skinIndices.copyVector4sArray(geometry.skinIndices))
      }

      if (geometry.skinWeights.length > 0) {
        var skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4)
        this.setAttribute('skinWeight', skinWeights.copyVector4sArray(geometry.skinWeights))
      } //

      if (geometry.boundingSphere !== null) {
        this.boundingSphere = geometry.boundingSphere.clone()
      }

      if (geometry.boundingBox !== null) {
        this.boundingBox = geometry.boundingBox.clone()
      }

      return this
    },
    computeBoundingBox: function computeBoundingBox() {
      if (this.boundingBox === null) {
        this.boundingBox = new Box3()
      }

      var position = this.attributes.position
      var morphAttributesPosition = this.morphAttributes.position

      if (position && position.isGLBufferAttribute) {
        console.error(
          'THREE.BufferGeometry.computeBoundingBox(): GLBufferAttribute requires a manual bounding box. Alternatively set "mesh.frustumCulled" to "false".',
          this
        )
        this.boundingBox.set(new Vector3(-Infinity, -Infinity, -Infinity), new Vector3(+Infinity, +Infinity, +Infinity))
        return
      }

      if (position !== undefined) {
        this.boundingBox.setFromBufferAttribute(position) // process morph attributes if present

        if (morphAttributesPosition) {
          for (var i = 0, il = morphAttributesPosition.length; i < il; i++) {
            var morphAttribute = morphAttributesPosition[i]

            _box$2.setFromBufferAttribute(morphAttribute)

            if (this.morphTargetsRelative) {
              _vector$4.addVectors(this.boundingBox.min, _box$2.min)

              this.boundingBox.expandByPoint(_vector$4)

              _vector$4.addVectors(this.boundingBox.max, _box$2.max)

              this.boundingBox.expandByPoint(_vector$4)
            } else {
              this.boundingBox.expandByPoint(_box$2.min)
              this.boundingBox.expandByPoint(_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: function computeBoundingSphere() {
      if (this.boundingSphere === null) {
        this.boundingSphere = new Sphere()
      }

      var position = this.attributes.position
      var morphAttributesPosition = this.morphAttributes.position

      if (position && position.isGLBufferAttribute) {
        console.error(
          'THREE.BufferGeometry.computeBoundingSphere(): GLBufferAttribute requires a manual bounding sphere. Alternatively set "mesh.frustumCulled" to "false".',
          this
        )
        this.boundingSphere.set(new Vector3(), Infinity)
        return
      }

      if (position) {
        // first, find the center of the bounding sphere
        var center = this.boundingSphere.center

        _box$2.setFromBufferAttribute(position) // process morph attributes if present

        if (morphAttributesPosition) {
          for (var i = 0, il = morphAttributesPosition.length; i < il; i++) {
            var morphAttribute = morphAttributesPosition[i]

            _boxMorphTargets.setFromBufferAttribute(morphAttribute)

            if (this.morphTargetsRelative) {
              _vector$4.addVectors(_box$2.min, _boxMorphTargets.min)

              _box$2.expandByPoint(_vector$4)

              _vector$4.addVectors(_box$2.max, _boxMorphTargets.max)

              _box$2.expandByPoint(_vector$4)
            } else {
              _box$2.expandByPoint(_boxMorphTargets.min)

              _box$2.expandByPoint(_boxMorphTargets.max)
            }
          }
        }

        _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

        var maxRadiusSq = 0

        for (var _i = 0, _il = position.count; _i < _il; _i++) {
          _vector$4.fromBufferAttribute(position, _i)

          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$4))
        } // process morph attributes if present

        if (morphAttributesPosition) {
          for (var _i2 = 0, _il2 = morphAttributesPosition.length; _i2 < _il2; _i2++) {
            var _morphAttribute = morphAttributesPosition[_i2]
            var morphTargetsRelative = this.morphTargetsRelative

            for (var j = 0, jl = _morphAttribute.count; j < jl; j++) {
              _vector$4.fromBufferAttribute(_morphAttribute, j)

              if (morphTargetsRelative) {
                _offset.fromBufferAttribute(position, j)

                _vector$4.add(_offset)
              }

              maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector$4))
            }
          }
        }

        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)
        }
      }
    },
    computeFaceNormals: function computeFaceNormals() {
      // backwards compatibility
    },
    computeVertexNormals: function computeVertexNormals() {
      var index = this.index
      var positionAttribute = this.getAttribute('position')

      if (positionAttribute !== undefined) {
        var normalAttribute = this.getAttribute('normal')

        if (normalAttribute === undefined) {
          normalAttribute = new BufferAttribute(new Float32Array(positionAttribute.count * 3), 3)
          this.setAttribute('normal', normalAttribute)
        } else {
          // reset existing normals to zero
          for (var i = 0, il = normalAttribute.count; i < il; i++) {
            normalAttribute.setXYZ(i, 0, 0, 0)
          }
        }

        var pA = new Vector3(),
          pB = new Vector3(),
          pC = new Vector3()
        var nA = new Vector3(),
          nB = new Vector3(),
          nC = new Vector3()
        var cb = new Vector3(),
          ab = new Vector3() // indexed elements

        if (index) {
          for (var _i3 = 0, _il3 = index.count; _i3 < _il3; _i3 += 3) {
            var vA = index.getX(_i3 + 0)
            var vB = index.getX(_i3 + 1)
            var vC = index.getX(_i3 + 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 (var _i4 = 0, _il4 = positionAttribute.count; _i4 < _il4; _i4 += 3) {
            pA.fromBufferAttribute(positionAttribute, _i4 + 0)
            pB.fromBufferAttribute(positionAttribute, _i4 + 1)
            pC.fromBufferAttribute(positionAttribute, _i4 + 2)
            cb.subVectors(pC, pB)
            ab.subVectors(pA, pB)
            cb.cross(ab)
            normalAttribute.setXYZ(_i4 + 0, cb.x, cb.y, cb.z)
            normalAttribute.setXYZ(_i4 + 1, cb.x, cb.y, cb.z)
            normalAttribute.setXYZ(_i4 + 2, cb.x, cb.y, cb.z)
          }
        }

        this.normalizeNormals()
        normalAttribute.needsUpdate = true
      }
    },
    merge: function merge(geometry, offset) {
      if (!(geometry && geometry.isBufferGeometry)) {
        console.error('THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry)
        return
      }

      if (offset === undefined) {
        offset = 0
        console.warn(
          'THREE.BufferGeometry.merge(): Overwriting original geometry, starting at offset=0. ' + 'Use BufferGeometryUtils.mergeBufferGeometries() for lossless merge.'
        )
      }

      var attributes = this.attributes

      for (var key in attributes) {
        if (geometry.attributes[key] === undefined) continue
        var attribute1 = attributes[key]
        var attributeArray1 = attribute1.array
        var attribute2 = geometry.attributes[key]
        var attributeArray2 = attribute2.array
        var attributeOffset = attribute2.itemSize * offset
        var length = Math.min(attributeArray2.length, attributeArray1.length - attributeOffset)

        for (var i = 0, j = attributeOffset; i < length; i++, j++) {
          attributeArray1[j] = attributeArray2[i]
        }
      }

      return this
    },
    normalizeNormals: function normalizeNormals() {
      var normals = this.attributes.normal

      for (var i = 0, il = normals.count; i < il; i++) {
        _vector$4.fromBufferAttribute(normals, i)

        _vector$4.normalize()

        normals.setXYZ(i, _vector$4.x, _vector$4.y, _vector$4.z)
      }
    },
    toNonIndexed: function toNonIndexed() {
      function convertBufferAttribute(attribute, indices) {
        var array = attribute.array
        var itemSize = attribute.itemSize
        var normalized = attribute.normalized
        var array2 = new array.constructor(indices.length * itemSize)
        var index = 0,
          index2 = 0

        for (var i = 0, l = indices.length; i < l; i++) {
          index = indices[i] * itemSize

          for (var j = 0; j < itemSize; j++) {
            array2[index2++] = array[index++]
          }
        }

        return new BufferAttribute(array2, itemSize, normalized)
      } //

      if (this.index === null) {
        console.warn('THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.')
        return this
      }

      var geometry2 = new BufferGeometry()
      var indices = this.index.array
      var attributes = this.attributes // attributes

      for (var name in attributes) {
        var attribute = attributes[name]
        var newAttribute = convertBufferAttribute(attribute, indices)
        geometry2.setAttribute(name, newAttribute)
      } // morph attributes

      var morphAttributes = this.morphAttributes

      for (var _name in morphAttributes) {
        var morphArray = []
        var morphAttribute = morphAttributes[_name] // morphAttribute: array of Float32BufferAttributes

        for (var i = 0, il = morphAttribute.length; i < il; i++) {
          var _attribute5 = morphAttribute[i]

          var _newAttribute = convertBufferAttribute(_attribute5, indices)

          morphArray.push(_newAttribute)
        }

        geometry2.morphAttributes[_name] = morphArray
      }

      geometry2.morphTargetsRelative = this.morphTargetsRelative // groups

      var groups = this.groups

      for (var _i5 = 0, l = groups.length; _i5 < l; _i5++) {
        var group = groups[_i5]
        geometry2.addGroup(group.start, group.count, group.materialIndex)
      }

      return geometry2
    },
    toJSON: function toJSON() {
      var data = {
        metadata: {
          version: 4.5,
          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) {
        var parameters = this.parameters

        for (var key in parameters) {
          if (parameters[key] !== undefined) data[key] = parameters[key]
        }

        return data
      }

      data.data = {
        attributes: {}
      }
      var index = this.index

      if (index !== null) {
        data.data.index = {
          type: index.array.constructor.name,
          array: Array.prototype.slice.call(index.array)
        }
      }

      var attributes = this.attributes

      for (var _key in attributes) {
        var attribute = attributes[_key]
        var attributeData = attribute.toJSON(data.data)
        if (attribute.name !== '') attributeData.name = attribute.name
        data.data.attributes[_key] = attributeData
      }

      var morphAttributes = {}
      var hasMorphAttributes = false

      for (var _key2 in this.morphAttributes) {
        var attributeArray = this.morphAttributes[_key2]
        var array = []

        for (var i = 0, il = attributeArray.length; i < il; i++) {
          var _attribute6 = attributeArray[i]

          var _attributeData = _attribute6.toJSON(data.data)

          if (_attribute6.name !== '') _attributeData.name = _attribute6.name
          array.push(_attributeData)
        }

        if (array.length > 0) {
          morphAttributes[_key2] = array
          hasMorphAttributes = true
        }
      }

      if (hasMorphAttributes) {
        data.data.morphAttributes = morphAttributes
        data.data.morphTargetsRelative = this.morphTargetsRelative
      }

      var groups = this.groups

      if (groups.length > 0) {
        data.data.groups = JSON.parse(JSON.stringify(groups))
      }

      var boundingSphere = this.boundingSphere

      if (boundingSphere !== null) {
        data.data.boundingSphere = {
          center: boundingSphere.center.toArray(),
          radius: boundingSphere.radius
        }
      }

      return data
    },
    clone: function clone() {
      /*
			 // Handle primitives
				 const parameters = this.parameters;
				 if ( parameters !== undefined ) {
				 const values = [];
				 for ( const key in parameters ) {
				 values.push( parameters[ key ] );
				 }
				 const geometry = Object.create( this.constructor.prototype );
			 this.constructor.apply( geometry, values );
			 return geometry;
				 }
				 return new this.constructor().copy( this );
			 */
      return new BufferGeometry().copy(this)
    },
    copy: function copy(source) {
      // reset
      this.index = null
      this.attributes = {}
      this.morphAttributes = {}
      this.groups = []
      this.boundingBox = null
      this.boundingSphere = null // used for storing cloned, shared data

      var data = {} // name

      this.name = source.name // index

      var index = source.index

      if (index !== null) {
        this.setIndex(index.clone(data))
      } // attributes

      var attributes = source.attributes

      for (var name in attributes) {
        var attribute = attributes[name]
        this.setAttribute(name, attribute.clone(data))
      } // morph attributes

      var morphAttributes = source.morphAttributes

      for (var _name2 in morphAttributes) {
        var array = []
        var morphAttribute = morphAttributes[_name2] // morphAttribute: array of Float32BufferAttributes

        for (var i = 0, l = morphAttribute.length; i < l; i++) {
          array.push(morphAttribute[i].clone(data))
        }

        this.morphAttributes[_name2] = array
      }

      this.morphTargetsRelative = source.morphTargetsRelative // groups

      var groups = source.groups

      for (var _i6 = 0, _l = groups.length; _i6 < _l; _i6++) {
        var group = groups[_i6]
        this.addGroup(group.start, group.count, group.materialIndex)
      } // bounding box

      var boundingBox = source.boundingBox

      if (boundingBox !== null) {
        this.boundingBox = boundingBox.clone()
      } // bounding sphere

      var 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: function dispose() {
      this.dispatchEvent({
        type: 'dispose'
      })
    }
  })

  var _inverseMatrix = new Matrix4()

  var _ray = new Ray()

  var _sphere = new Sphere()

  var _vA = new Vector3()

  var _vB = new Vector3()

  var _vC = new Vector3()

  var _tempA = new Vector3()

  var _tempB = new Vector3()

  var _tempC = new Vector3()

  var _morphA = new Vector3()

  var _morphB = new Vector3()

  var _morphC = new Vector3()

  var _uvA = new Vector2()

  var _uvB = new Vector2()

  var _uvC = new Vector2()

  var _intersectionPoint = new Vector3()

  var _intersectionPointWorld = new Vector3()

  function Mesh(geometry, material) {
    Object3D.call(this)
    this.type = 'Mesh'
    this.geometry = geometry !== undefined ? geometry : new BufferGeometry()
    this.material = material !== undefined ? material : new MeshBasicMaterial()
    this.updateMorphTargets()
  }

  Mesh.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Mesh,
    isMesh: true,
    copy: function copy(source) {
      Object3D.prototype.copy.call(this, source)

      if (source.morphTargetInfluences !== undefined) {
        this.morphTargetInfluences = source.morphTargetInfluences.slice()
      }

      if (source.morphTargetDictionary !== undefined) {
        this.morphTargetDictionary = Object.assign({}, source.morphTargetDictionary)
      }

      this.material = source.material
      this.geometry = source.geometry
      return this
    },
    updateMorphTargets: function updateMorphTargets() {
      var geometry = this.geometry

      if (geometry.isBufferGeometry) {
        var morphAttributes = geometry.morphAttributes
        var keys = Object.keys(morphAttributes)

        if (keys.length > 0) {
          var morphAttribute = morphAttributes[keys[0]]

          if (morphAttribute !== undefined) {
            this.morphTargetInfluences = []
            this.morphTargetDictionary = {}

            for (var m = 0, ml = morphAttribute.length; m < ml; m++) {
              var name = morphAttribute[m].name || String(m)
              this.morphTargetInfluences.push(0)
              this.morphTargetDictionary[name] = m
            }
          }
        }
      } else {
        var morphTargets = geometry.morphTargets

        if (morphTargets !== undefined && morphTargets.length > 0) {
          console.error('THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.')
        }
      }
    },
    raycast: function raycast(raycaster, intersects) {
      var geometry = this.geometry
      var material = this.material
      var matrixWorld = this.matrixWorld
      if (material === undefined) return // Checking boundingSphere distance to ray

      if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

      _sphere.copy(geometry.boundingSphere)

      _sphere.applyMatrix4(matrixWorld)

      if (raycaster.ray.intersectsSphere(_sphere) === false) return //

      _inverseMatrix.copy(matrixWorld).invert()

      _ray.copy(raycaster.ray).applyMatrix4(_inverseMatrix) // Check boundingBox before continuing

      if (geometry.boundingBox !== null) {
        if (_ray.intersectsBox(geometry.boundingBox) === false) return
      }

      var intersection

      if (geometry.isBufferGeometry) {
        var index = geometry.index
        var position = geometry.attributes.position
        var morphPosition = geometry.morphAttributes.position
        var morphTargetsRelative = geometry.morphTargetsRelative
        var uv = geometry.attributes.uv
        var uv2 = geometry.attributes.uv2
        var groups = geometry.groups
        var drawRange = geometry.drawRange

        if (index !== null) {
          // indexed buffer geometry
          if (Array.isArray(material)) {
            for (var i = 0, il = groups.length; i < il; i++) {
              var group = groups[i]
              var groupMaterial = material[group.materialIndex]
              var start = Math.max(group.start, drawRange.start)
              var end = Math.min(group.start + group.count, drawRange.start + drawRange.count)

              for (var j = start, jl = end; j < jl; j += 3) {
                var a = index.getX(j)
                var b = index.getX(j + 1)
                var c = index.getX(j + 2)
                intersection = checkBufferGeometryIntersection(this, groupMaterial, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, 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 {
            var _start = Math.max(0, drawRange.start)

            var _end = Math.min(index.count, drawRange.start + drawRange.count)

            for (var _i = _start, _il = _end; _i < _il; _i += 3) {
              var _a = index.getX(_i)

              var _b = index.getX(_i + 1)

              var _c = index.getX(_i + 2)

              intersection = checkBufferGeometryIntersection(this, material, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, _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 (var _i2 = 0, _il2 = groups.length; _i2 < _il2; _i2++) {
              var _group = groups[_i2]
              var _groupMaterial = material[_group.materialIndex]

              var _start2 = Math.max(_group.start, drawRange.start)

              var _end2 = Math.min(_group.start + _group.count, drawRange.start + drawRange.count)

              for (var _j = _start2, _jl = _end2; _j < _jl; _j += 3) {
                var _a2 = _j

                var _b2 = _j + 1

                var _c2 = _j + 2

                intersection = checkBufferGeometryIntersection(
                  this,
                  _groupMaterial,
                  raycaster,
                  _ray,
                  position,
                  morphPosition,
                  morphTargetsRelative,
                  uv,
                  uv2,
                  _a2,
                  _b2,
                  _c2
                )

                if (intersection) {
                  intersection.faceIndex = Math.floor(_j / 3) // triangle number in non-indexed buffer semantics

                  intersection.face.materialIndex = _group.materialIndex
                  intersects.push(intersection)
                }
              }
            }
          } else {
            var _start3 = Math.max(0, drawRange.start)

            var _end3 = Math.min(position.count, drawRange.start + drawRange.count)

            for (var _i3 = _start3, _il3 = _end3; _i3 < _il3; _i3 += 3) {
              var _a3 = _i3

              var _b3 = _i3 + 1

              var _c3 = _i3 + 2

              intersection = checkBufferGeometryIntersection(this, material, raycaster, _ray, position, morphPosition, morphTargetsRelative, uv, uv2, _a3, _b3, _c3)

              if (intersection) {
                intersection.faceIndex = Math.floor(_i3 / 3) // triangle number in non-indexed buffer semantics

                intersects.push(intersection)
              }
            }
          }
        }
      } else if (geometry.isGeometry) {
        var isMultiMaterial = Array.isArray(material)
        var vertices = geometry.vertices
        var faces = geometry.faces
        var uvs
        var faceVertexUvs = geometry.faceVertexUvs[0]
        if (faceVertexUvs.length > 0) uvs = faceVertexUvs

        for (var f = 0, fl = faces.length; f < fl; f++) {
          var face = faces[f]
          var faceMaterial = isMultiMaterial ? material[face.materialIndex] : material
          if (faceMaterial === undefined) continue
          var fvA = vertices[face.a]
          var fvB = vertices[face.b]
          var fvC = vertices[face.c]
          intersection = checkIntersection(this, faceMaterial, raycaster, _ray, fvA, fvB, fvC, _intersectionPoint)

          if (intersection) {
            if (uvs && uvs[f]) {
              var uvs_f = uvs[f]

              _uvA.copy(uvs_f[0])

              _uvB.copy(uvs_f[1])

              _uvC.copy(uvs_f[2])

              intersection.uv = Triangle.getUV(_intersectionPoint, fvA, fvB, fvC, _uvA, _uvB, _uvC, new Vector2())
            }

            intersection.face = face
            intersection.faceIndex = f
            intersects.push(intersection)
          }
        }
      }
    }
  })

  function checkIntersection(object, material, raycaster, ray, pA, pB, pC, point) {
    var intersect

    if (material.side === BackSide) {
      intersect = ray.intersectTriangle(pC, pB, pA, true, point)
    } else {
      intersect = ray.intersectTriangle(pA, pB, pC, material.side !== DoubleSide, point)
    }

    if (intersect === null) return null

    _intersectionPointWorld.copy(point)

    _intersectionPointWorld.applyMatrix4(object.matrixWorld)

    var distance = raycaster.ray.origin.distanceTo(_intersectionPointWorld)
    if (distance < raycaster.near || distance > raycaster.far) return null
    return {
      distance: distance,
      point: _intersectionPointWorld.clone(),
      object: object
    }
  }

  function checkBufferGeometryIntersection(object, material, raycaster, ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c) {
    _vA.fromBufferAttribute(position, a)

    _vB.fromBufferAttribute(position, b)

    _vC.fromBufferAttribute(position, c)

    var morphInfluences = object.morphTargetInfluences

    if (material.morphTargets && morphPosition && morphInfluences) {
      _morphA.set(0, 0, 0)

      _morphB.set(0, 0, 0)

      _morphC.set(0, 0, 0)

      for (var i = 0, il = morphPosition.length; i < il; i++) {
        var influence = morphInfluences[i]
        var morphAttribute = morphPosition[i]
        if (influence === 0) continue

        _tempA.fromBufferAttribute(morphAttribute, a)

        _tempB.fromBufferAttribute(morphAttribute, b)

        _tempC.fromBufferAttribute(morphAttribute, c)

        if (morphTargetsRelative) {
          _morphA.addScaledVector(_tempA, influence)

          _morphB.addScaledVector(_tempB, influence)

          _morphC.addScaledVector(_tempC, influence)
        } else {
          _morphA.addScaledVector(_tempA.sub(_vA), influence)

          _morphB.addScaledVector(_tempB.sub(_vB), influence)

          _morphC.addScaledVector(_tempC.sub(_vC), influence)
        }
      }

      _vA.add(_morphA)

      _vB.add(_morphB)

      _vC.add(_morphC)
    }

    if (object.isSkinnedMesh) {
      object.boneTransform(a, _vA)
      object.boneTransform(b, _vB)
      object.boneTransform(c, _vC)
    }

    var intersection = checkIntersection(object, material, raycaster, ray, _vA, _vB, _vC, _intersectionPoint)

    if (intersection) {
      if (uv) {
        _uvA.fromBufferAttribute(uv, a)

        _uvB.fromBufferAttribute(uv, b)

        _uvC.fromBufferAttribute(uv, c)

        intersection.uv = Triangle.getUV(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2())
      }

      if (uv2) {
        _uvA.fromBufferAttribute(uv2, a)

        _uvB.fromBufferAttribute(uv2, b)

        _uvC.fromBufferAttribute(uv2, c)

        intersection.uv2 = Triangle.getUV(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2())
      }

      var face = new Face3(a, b, c)
      Triangle.getNormal(_vA, _vB, _vC, face.normal)
      intersection.face = face
    }

    return intersection
  }

  var BoxBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(BoxBufferGeometry, _BufferGeometry)

    function BoxBufferGeometry(width, height, depth, widthSegments, heightSegments, depthSegments) {
      var _this

      if (width === void 0) {
        width = 1
      }

      if (height === void 0) {
        height = 1
      }

      if (depth === void 0) {
        depth = 1
      }

      if (widthSegments === void 0) {
        widthSegments = 1
      }

      if (heightSegments === void 0) {
        heightSegments = 1
      }

      if (depthSegments === void 0) {
        depthSegments = 1
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'BoxBufferGeometry'
      _this.parameters = {
        width: width,
        height: height,
        depth: depth,
        widthSegments: widthSegments,
        heightSegments: heightSegments,
        depthSegments: depthSegments
      }

      var scope = _assertThisInitialized(_this) // segments

      widthSegments = Math.floor(widthSegments)
      heightSegments = Math.floor(heightSegments)
      depthSegments = Math.floor(depthSegments) // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // helper variables

      var numberOfVertices = 0
      var 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 Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      function buildPlane(u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex) {
        var segmentWidth = width / gridX
        var segmentHeight = height / gridY
        var widthHalf = width / 2
        var heightHalf = height / 2
        var depthHalf = depth / 2
        var gridX1 = gridX + 1
        var gridY1 = gridY + 1
        var vertexCounter = 0
        var groupCount = 0
        var vector = new Vector3() // generate vertices, normals and uvs

        for (var iy = 0; iy < gridY1; iy++) {
          var y = iy * segmentHeight - heightHalf

          for (var ix = 0; ix < gridX1; ix++) {
            var 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 (var _iy = 0; _iy < gridY; _iy++) {
          for (var _ix = 0; _ix < gridX; _ix++) {
            var a = numberOfVertices + _ix + gridX1 * _iy
            var b = numberOfVertices + _ix + gridX1 * (_iy + 1)
            var c = numberOfVertices + (_ix + 1) + gridX1 * (_iy + 1)
            var 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
      }

      return _this
    }

    return BoxBufferGeometry
  })(BufferGeometry)

  /**
   * Uniform Utilities
   */
  function cloneUniforms(src) {
    var dst = {}

    for (var u in src) {
      dst[u] = {}

      for (var p in src[u]) {
        var property = src[u][p]

        if (
          property &&
          (property.isColor || property.isMatrix3 || property.isMatrix4 || property.isVector2 || property.isVector3 || property.isVector4 || property.isTexture)
        ) {
          dst[u][p] = property.clone()
        } else if (Array.isArray(property)) {
          dst[u][p] = property.slice()
        } else {
          dst[u][p] = property
        }
      }
    }

    return dst
  }
  function mergeUniforms(uniforms) {
    var merged = {}

    for (var u = 0; u < uniforms.length; u++) {
      var tmp = cloneUniforms(uniforms[u])

      for (var p in tmp) {
        merged[p] = tmp[p]
      }
    }

    return merged
  } // Legacy

  var UniformsUtils = {
    clone: cloneUniforms,
    merge: mergeUniforms
  }

  var default_vertex = 'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}'

  var default_fragment = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}'

  /**
   * parameters = {
   *	defines: { "label" : "value" },
   *	uniforms: { "parameter1": { value: 1.0 }, "parameter2": { value2: 2 } },
   *
   *	fragmentShader: <string>,
   *	vertexShader: <string>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>,
   *
   *	lights: <bool>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function ShaderMaterial(parameters) {
    Material.call(this)
    this.type = 'ShaderMaterial'
    this.defines = {}
    this.uniforms = {}
    this.vertexShader = default_vertex
    this.fragmentShader = 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.skinning = false // set to use skinning attribute streams

    this.morphTargets = false // set to use morph targets

    this.morphNormals = false // set to use morph normals

    this.extensions = {
      derivatives: false,
      // set to use derivatives
      fragDepth: false,
      // set to use fragment depth values
      drawBuffers: false,
      // set to use draw buffers
      shaderTextureLOD: false // set to use shader texture LOD
    } // 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],
      uv2: [0, 0]
    }
    this.index0AttributeName = undefined
    this.uniformsNeedUpdate = false
    this.glslVersion = null

    if (parameters !== undefined) {
      if (parameters.attributes !== undefined) {
        console.error('THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.')
      }

      this.setValues(parameters)
    }
  }

  ShaderMaterial.prototype = Object.create(Material.prototype)
  ShaderMaterial.prototype.constructor = ShaderMaterial
  ShaderMaterial.prototype.isShaderMaterial = true

  ShaderMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.fragmentShader = source.fragmentShader
    this.vertexShader = source.vertexShader
    this.uniforms = cloneUniforms(source.uniforms)
    this.defines = Object.assign({}, source.defines)
    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth
    this.lights = source.lights
    this.clipping = source.clipping
    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    this.extensions = Object.assign({}, source.extensions)
    this.glslVersion = source.glslVersion
    return this
  }

  ShaderMaterial.prototype.toJSON = function (meta) {
    var data = Material.prototype.toJSON.call(this, meta)
    data.glslVersion = this.glslVersion
    data.uniforms = {}

    for (var name in this.uniforms) {
      var uniform = this.uniforms[name]
      var 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
        } // note: the array variants v2v, v3v, v4v, m4v and tv are not supported so far
      }
    }

    if (Object.keys(this.defines).length > 0) data.defines = this.defines
    data.vertexShader = this.vertexShader
    data.fragmentShader = this.fragmentShader
    var extensions = {}

    for (var key in this.extensions) {
      if (this.extensions[key] === true) extensions[key] = true
    }

    if (Object.keys(extensions).length > 0) data.extensions = extensions
    return data
  }

  function Camera() {
    Object3D.call(this)
    this.type = 'Camera'
    this.matrixWorldInverse = new Matrix4()
    this.projectionMatrix = new Matrix4()
    this.projectionMatrixInverse = new Matrix4()
  }

  Camera.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Camera,
    isCamera: true,
    copy: function copy(source, recursive) {
      Object3D.prototype.copy.call(this, source, recursive)
      this.matrixWorldInverse.copy(source.matrixWorldInverse)
      this.projectionMatrix.copy(source.projectionMatrix)
      this.projectionMatrixInverse.copy(source.projectionMatrixInverse)
      return this
    },
    getWorldDirection: function getWorldDirection(target) {
      if (target === undefined) {
        console.warn('THREE.Camera: .getWorldDirection() target is now required')
        target = new Vector3()
      }

      this.updateWorldMatrix(true, false)
      var e = this.matrixWorld.elements
      return target.set(-e[8], -e[9], -e[10]).normalize()
    },
    updateMatrixWorld: function updateMatrixWorld(force) {
      Object3D.prototype.updateMatrixWorld.call(this, force)
      this.matrixWorldInverse.copy(this.matrixWorld).invert()
    },
    updateWorldMatrix: function updateWorldMatrix(updateParents, updateChildren) {
      Object3D.prototype.updateWorldMatrix.call(this, updateParents, updateChildren)
      this.matrixWorldInverse.copy(this.matrixWorld).invert()
    },
    clone: function clone() {
      return new this.constructor().copy(this)
    }
  })

  function PerspectiveCamera(fov, aspect, near, far) {
    if (fov === void 0) {
      fov = 50
    }

    if (aspect === void 0) {
      aspect = 1
    }

    if (near === void 0) {
      near = 0.1
    }

    if (far === void 0) {
      far = 2000
    }

    Camera.call(this)
    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()
  }

  PerspectiveCamera.prototype = Object.assign(Object.create(Camera.prototype), {
    constructor: PerspectiveCamera,
    isPerspectiveCamera: true,
    copy: function copy(source, recursive) {
      Camera.prototype.copy.call(this, 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.
     *
     * Values for focal length and film gauge must have the same unit.
     */
    setFocalLength: function setFocalLength(focalLength) {
      // see http://www.bobatkins.com/photography/technical/field_of_view.html
      var vExtentSlope = (0.5 * this.getFilmHeight()) / focalLength
      this.fov = MathUtils.RAD2DEG * 2 * Math.atan(vExtentSlope)
      this.updateProjectionMatrix()
    },

    /**
     * Calculates the focal length from the current .fov and .filmGauge.
     */
    getFocalLength: function getFocalLength() {
      var vExtentSlope = Math.tan(MathUtils.DEG2RAD * 0.5 * this.fov)
      return (0.5 * this.getFilmHeight()) / vExtentSlope
    },
    getEffectiveFOV: function getEffectiveFOV() {
      return MathUtils.RAD2DEG * 2 * Math.atan(Math.tan(MathUtils.DEG2RAD * 0.5 * this.fov) / this.zoom)
    },
    getFilmWidth: function getFilmWidth() {
      // film not completely covered in portrait format (aspect < 1)
      return this.filmGauge * Math.min(this.aspect, 1)
    },
    getFilmHeight: function getFilmHeight() {
      // film not completely covered in landscape format (aspect > 1)
      return this.filmGauge / Math.max(this.aspect, 1)
    },

    /**
     * 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.
     */
    setViewOffset: function 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: function clearViewOffset() {
      if (this.view !== null) {
        this.view.enabled = false
      }

      this.updateProjectionMatrix()
    },
    updateProjectionMatrix: function updateProjectionMatrix() {
      var near = this.near
      var top = (near * Math.tan(MathUtils.DEG2RAD * 0.5 * this.fov)) / this.zoom
      var height = 2 * top
      var width = this.aspect * height
      var left = -0.5 * width
      var view = this.view

      if (this.view !== null && this.view.enabled) {
        var fullWidth = view.fullWidth,
          fullHeight = view.fullHeight
        left += (view.offsetX * width) / fullWidth
        top -= (view.offsetY * height) / fullHeight
        width *= view.width / fullWidth
        height *= view.height / fullHeight
      }

      var skew = this.filmOffset
      if (skew !== 0) left += (near * skew) / this.getFilmWidth()
      this.projectionMatrix.makePerspective(left, left + width, top, top - height, near, this.far)
      this.projectionMatrixInverse.copy(this.projectionMatrix).invert()
    },
    toJSON: function toJSON(meta) {
      var data = Object3D.prototype.toJSON.call(this, 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
    }
  })

  var fov = 90,
    aspect = 1

  function CubeCamera(near, far, renderTarget) {
    Object3D.call(this)
    this.type = 'CubeCamera'

    if (renderTarget.isWebGLCubeRenderTarget !== true) {
      console.error('THREE.CubeCamera: The constructor now expects an instance of WebGLCubeRenderTarget as third parameter.')
      return
    }

    this.renderTarget = renderTarget
    var cameraPX = new PerspectiveCamera(fov, aspect, near, far)
    cameraPX.layers = this.layers
    cameraPX.up.set(0, -1, 0)
    cameraPX.lookAt(new Vector3(1, 0, 0))
    this.add(cameraPX)
    var cameraNX = new PerspectiveCamera(fov, aspect, near, far)
    cameraNX.layers = this.layers
    cameraNX.up.set(0, -1, 0)
    cameraNX.lookAt(new Vector3(-1, 0, 0))
    this.add(cameraNX)
    var cameraPY = new PerspectiveCamera(fov, aspect, near, far)
    cameraPY.layers = this.layers
    cameraPY.up.set(0, 0, 1)
    cameraPY.lookAt(new Vector3(0, 1, 0))
    this.add(cameraPY)
    var cameraNY = new PerspectiveCamera(fov, aspect, near, far)
    cameraNY.layers = this.layers
    cameraNY.up.set(0, 0, -1)
    cameraNY.lookAt(new Vector3(0, -1, 0))
    this.add(cameraNY)
    var cameraPZ = new PerspectiveCamera(fov, aspect, near, far)
    cameraPZ.layers = this.layers
    cameraPZ.up.set(0, -1, 0)
    cameraPZ.lookAt(new Vector3(0, 0, 1))
    this.add(cameraPZ)
    var cameraNZ = new PerspectiveCamera(fov, aspect, near, far)
    cameraNZ.layers = this.layers
    cameraNZ.up.set(0, -1, 0)
    cameraNZ.lookAt(new Vector3(0, 0, -1))
    this.add(cameraNZ)

    this.update = function (renderer, scene) {
      if (this.parent === null) this.updateMatrixWorld()
      var currentXrEnabled = renderer.xr.enabled
      var currentRenderTarget = renderer.getRenderTarget()
      renderer.xr.enabled = false
      var generateMipmaps = renderTarget.texture.generateMipmaps
      renderTarget.texture.generateMipmaps = false
      renderer.setRenderTarget(renderTarget, 0)
      renderer.render(scene, cameraPX)
      renderer.setRenderTarget(renderTarget, 1)
      renderer.render(scene, cameraNX)
      renderer.setRenderTarget(renderTarget, 2)
      renderer.render(scene, cameraPY)
      renderer.setRenderTarget(renderTarget, 3)
      renderer.render(scene, cameraNY)
      renderer.setRenderTarget(renderTarget, 4)
      renderer.render(scene, cameraPZ)
      renderTarget.texture.generateMipmaps = generateMipmaps
      renderer.setRenderTarget(renderTarget, 5)
      renderer.render(scene, cameraNZ)
      renderer.setRenderTarget(currentRenderTarget)
      renderer.xr.enabled = currentXrEnabled
    }
  }

  CubeCamera.prototype = Object.create(Object3D.prototype)
  CubeCamera.prototype.constructor = CubeCamera

  function CubeTexture(images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding) {
    images = images !== undefined ? images : []
    mapping = mapping !== undefined ? mapping : CubeReflectionMapping
    format = format !== undefined ? format : RGBFormat
    Texture.call(this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding)
    this.flipY = false // Why CubeTexture._needsFlipEnvMap is necessary:
    //
    // 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 _needsFlipEnvMap controls this conversion. The flip is not required (and thus _needsFlipEnvMap is set to false)
    // when using WebGLCubeRenderTarget.texture as a cube texture.

    this._needsFlipEnvMap = true
  }

  CubeTexture.prototype = Object.create(Texture.prototype)
  CubeTexture.prototype.constructor = CubeTexture
  CubeTexture.prototype.isCubeTexture = true
  Object.defineProperty(CubeTexture.prototype, 'images', {
    get: function get() {
      return this.image
    },
    set: function set(value) {
      this.image = value
    }
  })

  function WebGLCubeRenderTarget(size, options, dummy) {
    if (Number.isInteger(options)) {
      console.warn('THREE.WebGLCubeRenderTarget: constructor signature is now WebGLCubeRenderTarget( size, options )')
      options = dummy
    }

    WebGLRenderTarget.call(this, size, size, options)
    options = options || {}
    this.texture = new CubeTexture(
      undefined,
      options.mapping,
      options.wrapS,
      options.wrapT,
      options.magFilter,
      options.minFilter,
      options.format,
      options.type,
      options.anisotropy,
      options.encoding
    )
    this.texture._needsFlipEnvMap = false
  }

  WebGLCubeRenderTarget.prototype = Object.create(WebGLRenderTarget.prototype)
  WebGLCubeRenderTarget.prototype.constructor = WebGLCubeRenderTarget
  WebGLCubeRenderTarget.prototype.isWebGLCubeRenderTarget = true

  WebGLCubeRenderTarget.prototype.fromEquirectangularTexture = function (renderer, texture) {
    this.texture.type = texture.type
    this.texture.format = RGBAFormat // see #18859

    this.texture.encoding = texture.encoding
    this.texture.generateMipmaps = texture.generateMipmaps
    this.texture.minFilter = texture.minFilter
    this.texture.magFilter = texture.magFilter
    var shader = {
      uniforms: {
        tEquirect: {
          value: null
        }
      },
      vertexShader:
        /* glsl */
        '\n\n\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\tvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\n\t\t\t\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvWorldDirection = transformDirection( position, modelMatrix );\n\n\t\t\t\t#include <begin_vertex>\n\t\t\t\t#include <project_vertex>\n\n\t\t\t}\n\t\t',
      fragmentShader:
        /* glsl */
        '\n\n\t\t\tuniform sampler2D tEquirect;\n\n\t\t\tvarying vec3 vWorldDirection;\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 direction = normalize( vWorldDirection );\n\n\t\t\t\tvec2 sampleUV = equirectUv( direction );\n\n\t\t\t\tgl_FragColor = texture2D( tEquirect, sampleUV );\n\n\t\t\t}\n\t\t'
    }
    var geometry = new BoxBufferGeometry(5, 5, 5)
    var material = new ShaderMaterial({
      name: 'CubemapFromEquirect',
      uniforms: cloneUniforms(shader.uniforms),
      vertexShader: shader.vertexShader,
      fragmentShader: shader.fragmentShader,
      side: BackSide,
      blending: NoBlending
    })
    material.uniforms.tEquirect.value = texture
    var mesh = new Mesh(geometry, material)
    var currentMinFilter = texture.minFilter // Avoid blurred poles

    if (texture.minFilter === LinearMipmapLinearFilter) texture.minFilter = LinearFilter
    var camera = new CubeCamera(1, 10, this)
    camera.update(renderer, mesh)
    texture.minFilter = currentMinFilter
    mesh.geometry.dispose()
    mesh.material.dispose()
    return this
  }

  WebGLCubeRenderTarget.prototype.clear = function (renderer, color, depth, stencil) {
    var currentRenderTarget = renderer.getRenderTarget()

    for (var i = 0; i < 6; i++) {
      renderer.setRenderTarget(this, i)
      renderer.clear(color, depth, stencil)
    }

    renderer.setRenderTarget(currentRenderTarget)
  }

  function DataTexture(data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding) {
    Texture.call(this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding)
    this.image = {
      data: data || null,
      width: width || 1,
      height: height || 1
    }
    this.magFilter = magFilter !== undefined ? magFilter : NearestFilter
    this.minFilter = minFilter !== undefined ? minFilter : NearestFilter
    this.generateMipmaps = false
    this.flipY = false
    this.unpackAlignment = 1
    this.needsUpdate = true
  }

  DataTexture.prototype = Object.create(Texture.prototype)
  DataTexture.prototype.constructor = DataTexture
  DataTexture.prototype.isDataTexture = true

  var _sphere$1 = /*@__PURE__*/ new Sphere()

  var _vector$5 = /*@__PURE__*/ new Vector3()

  var Frustum = /*#__PURE__*/ (function () {
    function Frustum(p0, p1, p2, p3, p4, p5) {
      this.planes = [
        p0 !== undefined ? p0 : new Plane(),
        p1 !== undefined ? p1 : new Plane(),
        p2 !== undefined ? p2 : new Plane(),
        p3 !== undefined ? p3 : new Plane(),
        p4 !== undefined ? p4 : new Plane(),
        p5 !== undefined ? p5 : new Plane()
      ]
    }

    var _proto = Frustum.prototype

    _proto.set = function set(p0, p1, p2, p3, p4, p5) {
      var 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
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(frustum) {
      var planes = this.planes

      for (var i = 0; i < 6; i++) {
        planes[i].copy(frustum.planes[i])
      }

      return this
    }

    _proto.setFromProjectionMatrix = function setFromProjectionMatrix(m) {
      var planes = this.planes
      var me = m.elements
      var me0 = me[0],
        me1 = me[1],
        me2 = me[2],
        me3 = me[3]
      var me4 = me[4],
        me5 = me[5],
        me6 = me[6],
        me7 = me[7]
      var me8 = me[8],
        me9 = me[9],
        me10 = me[10],
        me11 = me[11]
      var 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()
      planes[5].setComponents(me3 + me2, me7 + me6, me11 + me10, me15 + me14).normalize()
      return this
    }

    _proto.intersectsObject = function intersectsObject(object) {
      var geometry = object.geometry
      if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

      _sphere$1.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld)

      return this.intersectsSphere(_sphere$1)
    }

    _proto.intersectsSprite = function intersectsSprite(sprite) {
      _sphere$1.center.set(0, 0, 0)

      _sphere$1.radius = 0.7071067811865476

      _sphere$1.applyMatrix4(sprite.matrixWorld)

      return this.intersectsSphere(_sphere$1)
    }

    _proto.intersectsSphere = function intersectsSphere(sphere) {
      var planes = this.planes
      var center = sphere.center
      var negRadius = -sphere.radius

      for (var i = 0; i < 6; i++) {
        var distance = planes[i].distanceToPoint(center)

        if (distance < negRadius) {
          return false
        }
      }

      return true
    }

    _proto.intersectsBox = function intersectsBox(box) {
      var planes = this.planes

      for (var i = 0; i < 6; i++) {
        var plane = planes[i] // corner at max distance

        _vector$5.x = plane.normal.x > 0 ? box.max.x : box.min.x
        _vector$5.y = plane.normal.y > 0 ? box.max.y : box.min.y
        _vector$5.z = plane.normal.z > 0 ? box.max.z : box.min.z

        if (plane.distanceToPoint(_vector$5) < 0) {
          return false
        }
      }

      return true
    }

    _proto.containsPoint = function containsPoint(point) {
      var planes = this.planes

      for (var i = 0; i < 6; i++) {
        if (planes[i].distanceToPoint(point) < 0) {
          return false
        }
      }

      return true
    }

    return Frustum
  })()

  function WebGLAnimation() {
    var context = null
    var isAnimating = false
    var animationLoop = null
    var requestId = null

    function onAnimationFrame(time, frame) {
      animationLoop(time, frame)
      requestId = context.requestAnimationFrame(onAnimationFrame)
    }

    return {
      start: function start() {
        if (isAnimating === true) return
        if (animationLoop === null) return
        requestId = context.requestAnimationFrame(onAnimationFrame)
        isAnimating = true
      },
      stop: function stop() {
        context.cancelAnimationFrame(requestId)
        isAnimating = false
      },
      setAnimationLoop: function setAnimationLoop(callback) {
        animationLoop = callback
      },
      setContext: function setContext(value) {
        context = value
      }
    }
  }

  function WebGLAttributes(gl, capabilities) {
    var isWebGL2 = capabilities.isWebGL2
    var buffers = new WeakMap()

    function createBuffer(attribute, bufferType) {
      var array = attribute.array
      var usage = attribute.usage
      var buffer = gl.createBuffer()
      gl.bindBuffer(bufferType, buffer)
      gl.bufferData(bufferType, array, usage)
      attribute.onUploadCallback()
      var type = 5126

      if (array instanceof Float32Array) {
        type = 5126
      } else if (array instanceof Float64Array) {
        console.warn('THREE.WebGLAttributes: Unsupported data buffer format: Float64Array.')
      } else if (array instanceof Uint16Array) {
        if (attribute.isFloat16BufferAttribute) {
          if (isWebGL2) {
            type = 5131
          } else {
            console.warn('THREE.WebGLAttributes: Usage of Float16BufferAttribute requires WebGL2.')
          }
        } else {
          type = 5123
        }
      } else if (array instanceof Int16Array) {
        type = 5122
      } else if (array instanceof Uint32Array) {
        type = 5125
      } else if (array instanceof Int32Array) {
        type = 5124
      } else if (array instanceof Int8Array) {
        type = 5120
      } else if (array instanceof Uint8Array) {
        type = 5121
      }

      return {
        buffer: buffer,
        type: type,
        bytesPerElement: array.BYTES_PER_ELEMENT,
        version: attribute.version
      }
    }

    function updateBuffer(buffer, attribute, bufferType) {
      var array = attribute.array
      var updateRange = attribute.updateRange
      gl.bindBuffer(bufferType, buffer)

      if (updateRange.count === -1) {
        // Not using update ranges
        gl.bufferSubData(bufferType, 0, array)
      } else {
        if (isWebGL2) {
          gl.bufferSubData(bufferType, updateRange.offset * array.BYTES_PER_ELEMENT, array, updateRange.offset, updateRange.count)
        } else {
          gl.bufferSubData(bufferType, updateRange.offset * array.BYTES_PER_ELEMENT, array.subarray(updateRange.offset, updateRange.offset + updateRange.count))
        }

        updateRange.count = -1 // reset range
      }
    } //

    function get(attribute) {
      if (attribute.isInterleavedBufferAttribute) attribute = attribute.data
      return buffers.get(attribute)
    }

    function remove(attribute) {
      if (attribute.isInterleavedBufferAttribute) attribute = attribute.data
      var data = buffers.get(attribute)

      if (data) {
        gl.deleteBuffer(data.buffer)
        buffers.delete(attribute)
      }
    }

    function update(attribute, bufferType) {
      if (attribute.isGLBufferAttribute) {
        var 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
      }

      if (attribute.isInterleavedBufferAttribute) attribute = attribute.data
      var data = buffers.get(attribute)

      if (data === undefined) {
        buffers.set(attribute, createBuffer(attribute, bufferType))
      } else if (data.version < attribute.version) {
        updateBuffer(data.buffer, attribute, bufferType)
        data.version = attribute.version
      }
    }

    return {
      get: get,
      remove: remove,
      update: update
    }
  }

  var PlaneBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(PlaneBufferGeometry, _BufferGeometry)

    function PlaneBufferGeometry(width, height, widthSegments, heightSegments) {
      var _this

      if (width === void 0) {
        width = 1
      }

      if (height === void 0) {
        height = 1
      }

      if (widthSegments === void 0) {
        widthSegments = 1
      }

      if (heightSegments === void 0) {
        heightSegments = 1
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'PlaneBufferGeometry'
      _this.parameters = {
        width: width,
        height: height,
        widthSegments: widthSegments,
        heightSegments: heightSegments
      }
      var width_half = width / 2
      var height_half = height / 2
      var gridX = Math.floor(widthSegments)
      var gridY = Math.floor(heightSegments)
      var gridX1 = gridX + 1
      var gridY1 = gridY + 1
      var segment_width = width / gridX
      var segment_height = height / gridY //

      var indices = []
      var vertices = []
      var normals = []
      var uvs = []

      for (var iy = 0; iy < gridY1; iy++) {
        var y = iy * segment_height - height_half

        for (var ix = 0; ix < gridX1; ix++) {
          var 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 (var _iy = 0; _iy < gridY; _iy++) {
        for (var _ix = 0; _ix < gridX; _ix++) {
          var a = _ix + gridX1 * _iy
          var b = _ix + gridX1 * (_iy + 1)
          var c = _ix + 1 + gridX1 * (_iy + 1)
          var d = _ix + 1 + gridX1 * _iy
          indices.push(a, b, d)
          indices.push(b, c, d)
        }
      }

      _this.setIndex(indices)

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      return _this
    }

    return PlaneBufferGeometry
  })(BufferGeometry)

  var alphamap_fragment = '#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif'

  var alphamap_pars_fragment = '#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif'

  var alphatest_fragment = '#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif'

  var aomap_fragment =
    '#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( STANDARD )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif'

  var aomap_pars_fragment = '#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif'

  var begin_vertex = 'vec3 transformed = vec3( position );'

  var beginnormal_vertex = 'vec3 objectNormal = vec3( normal );\n#ifdef USE_TANGENT\n\tvec3 objectTangent = vec3( tangent.xyz );\n#endif'

  var bsdfs =
    'vec2 integrateSpecularBRDF( const in float dotNV, const in float roughness ) {\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\treturn vec2( -1.04, 1.04 ) * a004 + r.zw;\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\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#else\n\tif( cutoffDistance > 0.0 && decayExponent > 0.0 ) {\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n\t}\n\treturn 1.0;\n#endif\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nvec3 F_Schlick_RoughnessDependent( const in vec3 F0, const in float dotNV, const in float roughness ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotNV - 6.98316 ) * dotNV );\n\tvec3 Fr = max( vec3( 1.0 - roughness ), F0 ) - F0;\n\treturn Fr * fresnel + F0;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_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}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + viewDir );\n\tfloat dotNL = saturate( dot( normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tfloat dotNH = saturate( dot( normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * 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}\nvec3 BRDF_Specular_GGX_Environment( const in vec3 viewDir, const in vec3 normal, const in vec3 specularColor, const in float roughness ) {\n\tfloat dotNV = saturate( dot( normal, viewDir ) );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\treturn specularColor * brdf.x + brdf.y;\n}\nvoid BRDF_Specular_Multiscattering_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness, inout vec3 singleScatter, inout vec3 multiScatter ) {\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tvec3 F = F_Schlick_RoughnessDependent( specularColor, dotNV, roughness );\n\tvec2 brdf = integrateSpecularBRDF( dotNV, roughness );\n\tvec3 FssEss = F * brdf.x + brdf.y;\n\tfloat Ess = brdf.x + brdf.y;\n\tfloat Ems = 1.0 - Ess;\n\tvec3 Favg = specularColor + ( 1.0 - specularColor ) * 0.047619;\tvec3 Fms = FssEss * Favg / ( 1.0 - Ems * Favg );\n\tsingleScatter += FssEss;\n\tmultiScatter += Fms * Ems;\n}\nfloat 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_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_BlinnPhong_Implicit( );\n\tfloat D = D_BlinnPhong( shininess, dotNH );\n\treturn F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n#if defined( USE_SHEEN )\nfloat D_Charlie(float roughness, float NoH) {\n\tfloat invAlpha = 1.0 / roughness;\n\tfloat cos2h = NoH * NoH;\n\tfloat sin2h = max(1.0 - cos2h, 0.0078125);\treturn (2.0 + invAlpha) * pow(sin2h, invAlpha * 0.5) / (2.0 * PI);\n}\nfloat V_Neubelt(float NoV, float NoL) {\n\treturn saturate(1.0 / (4.0 * (NoL + NoV - NoL * NoV)));\n}\nvec3 BRDF_Specular_Sheen( const in float roughness, const in vec3 L, const in GeometricContext geometry, vec3 specularColor ) {\n\tvec3 N = geometry.normal;\n\tvec3 V = geometry.viewDir;\n\tvec3 H = normalize( V + L );\n\tfloat dotNH = saturate( dot( N, H ) );\n\treturn specularColor * D_Charlie( roughness, dotNH ) * V_Neubelt( dot(N, V), dot(N, L) );\n}\n#endif'

  var bumpmap_pars_fragment =
    '#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\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 );\n\t\tfDet *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\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 clipping_planes_fragment =
    '#if NUM_CLIPPING_PLANES > 0\n\tvec4 plane;\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; i ++ ) {\n\t\tplane = clippingPlanes[ i ];\n\t\tif ( dot( vClipPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t#pragma unroll_loop_end\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\t#pragma unroll_loop_start\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; i ++ ) {\n\t\t\tplane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vClipPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\t#pragma unroll_loop_end\n\t\tif ( clipped ) discard;\n\t#endif\n#endif'

  var clipping_planes_pars_fragment = '#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif'

  var clipping_planes_pars_vertex = '#if NUM_CLIPPING_PLANES > 0\n\tvarying vec3 vClipPosition;\n#endif'

  var clipping_planes_vertex = '#if NUM_CLIPPING_PLANES > 0\n\tvClipPosition = - mvPosition.xyz;\n#endif'

  var color_fragment = '#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif'

  var color_pars_fragment = '#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif'

  var color_pars_vertex = '#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvarying vec3 vColor;\n#endif'

  var color_vertex =
    '#if defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )\n\tvColor = vec3( 1.0 );\n#endif\n#ifdef USE_COLOR\n\tvColor.xyz *= color.xyz;\n#endif\n#ifdef USE_INSTANCING_COLOR\n\tvColor.xyz *= instanceColor.xyz;\n#endif'

  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; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\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 max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }\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};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n#ifdef CLEARCOAT\n\tvec3 clearcoatNormal;\n#endif\n};\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}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\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}\nfloat linearToRelativeLuminance( const in vec3 color ) {\n\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\n\treturn dot( weights, color.rgb );\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}'

  var cube_uv_reflection_fragment =
    '#ifdef ENVMAP_TYPE_CUBE_UV\n\t#define cubeUV_maxMipLevel 8.0\n\t#define cubeUV_minMipLevel 4.0\n\t#define cubeUV_maxTileSize 256.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\tfloat texelSize = 1.0 / ( 3.0 * cubeUV_maxTileSize );\n\t\tvec2 uv = getUV( direction, face ) * ( faceSize - 1.0 );\n\t\tvec2 f = fract( uv );\n\t\tuv += 0.5 - f;\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\tif ( mipInt < cubeUV_maxMipLevel ) {\n\t\t\tuv.y += 2.0 * cubeUV_maxTileSize;\n\t\t}\n\t\tuv.y += filterInt * 2.0 * cubeUV_minTileSize;\n\t\tuv.x += 3.0 * max( 0.0, cubeUV_maxTileSize - 2.0 * faceSize );\n\t\tuv *= texelSize;\n\t\tvec3 tl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x += texelSize;\n\t\tvec3 tr = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.y += texelSize;\n\t\tvec3 br = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tuv.x -= texelSize;\n\t\tvec3 bl = envMapTexelToLinear( texture2D( envMap, uv ) ).rgb;\n\t\tvec3 tm = mix( tl, tr, f.x );\n\t\tvec3 bm = mix( bl, br, f.x );\n\t\treturn mix( tm, bm, f.y );\n\t}\n\t#define r0 1.0\n\t#define v0 0.339\n\t#define m0 - 2.0\n\t#define r1 0.8\n\t#define v1 0.276\n\t#define m1 - 1.0\n\t#define r4 0.4\n\t#define v4 0.046\n\t#define m4 2.0\n\t#define r5 0.305\n\t#define v5 0.016\n\t#define m5 3.0\n\t#define r6 0.21\n\t#define v6 0.0038\n\t#define m6 4.0\n\tfloat roughnessToMip( float roughness ) {\n\t\tfloat mip = 0.0;\n\t\tif ( roughness >= r1 ) {\n\t\t\tmip = ( r0 - roughness ) * ( m1 - m0 ) / ( r0 - r1 ) + m0;\n\t\t} else if ( roughness >= r4 ) {\n\t\t\tmip = ( r1 - roughness ) * ( m4 - m1 ) / ( r1 - r4 ) + m1;\n\t\t} else if ( roughness >= r5 ) {\n\t\t\tmip = ( r4 - roughness ) * ( m5 - m4 ) / ( r4 - r5 ) + m4;\n\t\t} else if ( roughness >= r6 ) {\n\t\t\tmip = ( r5 - roughness ) * ( m6 - m5 ) / ( r5 - r6 ) + 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 ), m0, cubeUV_maxMipLevel );\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 defaultnormal_vertex =
    'vec3 transformedNormal = objectNormal;\n#ifdef USE_INSTANCING\n\tmat3 m = mat3( instanceMatrix );\n\ttransformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n\ttransformedNormal = m * transformedNormal;\n#endif\ntransformedNormal = normalMatrix * transformedNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n#ifdef USE_TANGENT\n\tvec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n\t#ifdef FLIP_SIDED\n\t\ttransformedTangent = - transformedTangent;\n\t#endif\n#endif'

  var displacementmap_pars_vertex =
    '#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif'

  var displacementmap_vertex =
    '#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, vUv ).x * displacementScale + displacementBias );\n#endif'

  var emissivemap_fragment =
    '#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif'

  var emissivemap_pars_fragment = '#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif'

  var encodings_fragment = 'gl_FragColor = linearToOutputTexel( gl_FragColor );'

  var encodings_pars_fragment =
    '\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( gammaFactor ) ), value.a );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.rgb, vec3( 1.0 / gammaFactor ) ), value.a );\n}\nvec4 sRGBToLinear( 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 LinearTosRGB( 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}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * value.a * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat M = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.r, max( value.g, value.b ) );\n\tfloat D = max( maxRange / maxRGB, 1.0 );\n\tD = clamp( floor( D ) / 255.0, 0.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value ) {\n\tvec3 Xp_Y_XYZp = cLogLuvM * value.rgb;\n\tXp_Y_XYZp = max( Xp_Y_XYZp, vec3( 1e-6, 1e-6, 1e-6 ) );\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract( Le );\n\tvResult.z = ( Le - ( floor( vResult.w * 255.0 ) ) / 255.0 ) / 255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2( ( Le - 127.0 ) / 2.0 );\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = cLogLuvInverseM * Xp_Y_XYZp.rgb;\n\treturn vec4( max( vRGB, 0.0 ), 1.0 );\n}'

  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, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\tvec4 envColor = textureCubeUV( envMap, reflectVec, 0.0 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\t#ifndef ENVMAP_TYPE_CUBE_UV\n\t\tenvColor = envMapTexelToLinear( envColor );\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 envmap_common_pars_fragment =
    '#ifdef USE_ENVMAP\n\tuniform float envMapIntensity;\n\tuniform float flipEnvMap;\n\tuniform int maxMipLevel;\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 envmap_pars_fragment =
    '#ifdef USE_ENVMAP\n\tuniform float reflectivity;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\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 envmap_pars_vertex =
    '#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )\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 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 fog_vertex = '#ifdef USE_FOG\n\tfogDepth = - mvPosition.z;\n#endif'

  var fog_pars_vertex = '#ifdef USE_FOG\n\tvarying float fogDepth;\n#endif'

  var fog_fragment =
    '#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif'

  var fog_pars_fragment =
    '#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\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 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 texture2D( gradientMap, coord ).rgb;\n\t#else\n\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t#endif\n}'

  var lightmap_fragment =
    '#ifdef USE_LIGHTMAP\n\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\treflectedLight.indirectDiffuse += PI * lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n#endif'

  var lightmap_pars_fragment = '#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif'

  var lights_lambert_vertex =
    'vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\nvIndirectFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n\tvLightBack = vec3( 0.0 );\n\tvIndirectBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\nvIndirectFront += getAmbientLightIrradiance( ambientLightColor );\nvIndirectFront += getLightProbeIrradiance( lightProbe, geometry );\n#ifdef DOUBLE_SIDED\n\tvIndirectBack += getAmbientLightIrradiance( ambientLightColor );\n\tvIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry );\n#endif\n#if NUM_POINT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_DIR_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n\t#pragma unroll_loop_end\n#endif'

  var lights_pars_begin =
    'uniform bool receiveShadow;\nuniform vec3 ambientLightColor;\nuniform vec3 lightProbe[ 9 ];\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 GeometricContext geometry ) {\n\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\tvec3 irradiance = shGetIrradianceAt( worldNormal, lightProbe );\n\treturn irradiance;\n}\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\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 getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.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 getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.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 getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.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 GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif'

  var envmap_physical_pars_fragment =
    '#if defined( USE_ENVMAP )\n\t#ifdef ENVMAP_MODE_REFRACTION\n\t\tuniform float refractionRatio;\n\t#endif\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, worldNormal, 1.0 );\n\t\t#else\n\t\t\tvec4 envMapColor = vec4( 0.0 );\n\t\t#endif\n\t\treturn PI * envMapColor.rgb * envMapIntensity;\n\t}\n\tfloat getSpecularMIPLevel( const in float roughness, const in int maxMIPLevel ) {\n\t\tfloat maxMIPLevelScalar = float( maxMIPLevel );\n\t\tfloat sigma = PI * roughness * roughness / ( 1.0 + roughness );\n\t\tfloat desiredMIPLevel = maxMIPLevelScalar + log2( sigma );\n\t\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n\t}\n\tvec3 getLightProbeIndirectRadiance( const in vec3 viewDir, const in vec3 normal, const in float roughness, const in int maxMIPLevel ) {\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( -viewDir, normal );\n\t\t\treflectVec = normalize( mix( reflectVec, normal, roughness * roughness) );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( -viewDir, normal, refractionRatio );\n\t\t#endif\n\t\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n\t\tfloat specularMIPLevel = getSpecularMIPLevel( roughness, maxMIPLevel );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#else\n\t\t\t\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n\t\t\t#endif\n\t\t\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n\t\t#elif defined( ENVMAP_TYPE_CUBE_UV )\n\t\t\tvec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );\n\t\t#endif\n\t\treturn envMapColor.rgb * envMapIntensity;\n\t}\n#endif'

  var lights_toon_fragment = 'ToonMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;'

  var lights_toon_pars_fragment =
    'varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct ToonMaterial {\n\tvec3 diffuseColor;\n};\nvoid RE_Direct_Toon( const in IncidentLight directLight, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Toon( const in vec3 irradiance, const in GeometricContext geometry, const in ToonMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_Toon\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_Toon\n#define Material_LightProbeLOD( material )\t(0)'

  var lights_phong_fragment =
    'BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;'

  var lights_phong_pars_fragment =
    'varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\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 GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)'

  var lights_physical_fragment =
    'PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nvec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );\nfloat geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );\nmaterial.specularRoughness = max( roughnessFactor, 0.0525 );material.specularRoughness += geometryRoughness;\nmaterial.specularRoughness = min( material.specularRoughness, 1.0 );\n#ifdef REFLECTIVITY\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#endif\n#ifdef CLEARCOAT\n\tmaterial.clearcoat = clearcoat;\n\tmaterial.clearcoatRoughness = clearcoatRoughness;\n\t#ifdef USE_CLEARCOATMAP\n\t\tmaterial.clearcoat *= texture2D( clearcoatMap, vUv ).x;\n\t#endif\n\t#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\t\tmaterial.clearcoatRoughness *= texture2D( clearcoatRoughnessMap, vUv ).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_SHEEN\n\tmaterial.sheenColor = sheen;\n#endif'

  var lights_physical_pars_fragment =
    'struct PhysicalMaterial {\n\tvec3 diffuseColor;\n\tfloat specularRoughness;\n\tvec3 specularColor;\n#ifdef CLEARCOAT\n\tfloat clearcoat;\n\tfloat clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tvec3 sheenColor;\n#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearcoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\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.specularRoughness;\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 GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNL = saturate( dot( geometry.clearcoatNormal, directLight.direction ) );\n\t\tvec3 ccIrradiance = ccDotNL * directLight.color;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tccIrradiance *= PI;\n\t\t#endif\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t\treflectedLight.directSpecular += ccIrradiance * material.clearcoat * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\t#ifdef USE_SHEEN\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_Sheen(\n\t\t\tmaterial.specularRoughness,\n\t\t\tdirectLight.direction,\n\t\t\tgeometry,\n\t\t\tmaterial.sheenColor\n\t\t);\n\t#else\n\t\treflectedLight.directSpecular += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry.viewDir, geometry.normal, material.specularColor, material.specularRoughness);\n\t#endif\n\treflectedLight.directDiffuse += ( 1.0 - clearcoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 irradiance, const in vec3 clearcoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight) {\n\t#ifdef CLEARCOAT\n\t\tfloat ccDotNV = saturate( dot( geometry.clearcoatNormal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular += clearcoatRadiance * material.clearcoat * BRDF_Specular_GGX_Environment( geometry.viewDir, geometry.clearcoatNormal, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearcoatRoughness );\n\t\tfloat ccDotNL = ccDotNV;\n\t\tfloat clearcoatDHR = material.clearcoat * clearcoatDHRApprox( material.clearcoatRoughness, ccDotNL );\n\t#else\n\t\tfloat clearcoatDHR = 0.0;\n\t#endif\n\tfloat clearcoatInv = 1.0 - clearcoatDHR;\n\tvec3 singleScattering = vec3( 0.0 );\n\tvec3 multiScattering = vec3( 0.0 );\n\tvec3 cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;\n\tBRDF_Specular_Multiscattering_Environment( geometry, material.specularColor, material.specularRoughness, singleScattering, multiScattering );\n\tvec3 diffuse = material.diffuseColor * ( 1.0 - ( singleScattering + multiScattering ) );\n\treflectedLight.indirectSpecular += clearcoatInv * 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 lights_fragment_begin =
    '\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n#ifdef CLEARCOAT\n\tgeometry.clearcoatNormal = clearcoatNormal;\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\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n\t\tpointLightShadow = pointLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, 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\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\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n\t\tspotLightShadow = spotLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, 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\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\t\tdirectionalLightShadow = directionalLightShadows[ i ];\n\t\tdirectLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, 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, geometry, 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\tirradiance += getLightProbeIrradiance( lightProbe, geometry );\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 ], geometry );\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 lights_fragment_maps =
    '#if defined( RE_IndirectDiffuse )\n\t#ifdef USE_LIGHTMAP\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\tvec3 lightMapIrradiance = lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( STANDARD ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tiblIrradiance += getLightProbeIndirectIrradiance( geometry, maxMipLevel );\n\t#endif\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tradiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.normal, material.specularRoughness, maxMipLevel );\n\t#ifdef CLEARCOAT\n\t\tclearcoatRadiance += getLightProbeIndirectRadiance( geometry.viewDir, geometry.clearcoatNormal, material.clearcoatRoughness, maxMipLevel );\n\t#endif\n#endif'

  var lights_fragment_end =
    '#if defined( RE_IndirectDiffuse )\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( RE_IndirectSpecular )\n\tRE_IndirectSpecular( radiance, iblIrradiance, clearcoatRadiance, geometry, material, reflectedLight );\n#endif'

  var logdepthbuf_fragment =
    '#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tgl_FragDepthEXT = vIsPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;\n#endif'

  var logdepthbuf_pars_fragment =
    '#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\n\tuniform float logDepthBufFC;\n\tvarying float vFragDepth;\n\tvarying float vIsPerspective;\n#endif'

  var logdepthbuf_pars_vertex =
    '#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t\tvarying float vIsPerspective;\n\t#else\n\t\tuniform float logDepthBufFC;\n\t#endif\n#endif'

  var logdepthbuf_vertex =
    '#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t\tvIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );\n\t#else\n\t\tif ( isPerspectiveMatrix( projectionMatrix ) ) {\n\t\t\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\n\t\t\tgl_Position.z *= gl_Position.w;\n\t\t}\n\t#endif\n#endif'

  var map_fragment = '#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif'

  var map_pars_fragment = '#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif'

  var map_particle_fragment =
    '#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\n#endif\n#ifdef USE_MAP\n\tvec4 mapTexel = texture2D( map, uv );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, uv ).g;\n#endif'

  var map_particle_pars_fragment =
    '#if defined( USE_MAP ) || defined( USE_ALPHAMAP )\n\tuniform mat3 uvTransform;\n#endif\n#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif'

  var metalnessmap_fragment =
    'float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif'

  var metalnessmap_pars_fragment = '#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif'

  var morphnormal_vertex =
    '#ifdef USE_MORPHNORMALS\n\tobjectNormal *= morphTargetBaseInfluence;\n\tobjectNormal += morphNormal0 * morphTargetInfluences[ 0 ];\n\tobjectNormal += morphNormal1 * morphTargetInfluences[ 1 ];\n\tobjectNormal += morphNormal2 * morphTargetInfluences[ 2 ];\n\tobjectNormal += morphNormal3 * morphTargetInfluences[ 3 ];\n#endif'

  var morphtarget_pars_vertex =
    '#ifdef USE_MORPHTARGETS\n\tuniform float morphTargetBaseInfluence;\n\t#ifndef USE_MORPHNORMALS\n\t\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\t\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif'

  var morphtarget_vertex =
    '#ifdef USE_MORPHTARGETS\n\ttransformed *= morphTargetBaseInfluence;\n\ttransformed += morphTarget0 * morphTargetInfluences[ 0 ];\n\ttransformed += morphTarget1 * morphTargetInfluences[ 1 ];\n\ttransformed += morphTarget2 * morphTargetInfluences[ 2 ];\n\ttransformed += morphTarget3 * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\t\ttransformed += morphTarget4 * morphTargetInfluences[ 4 ];\n\t\ttransformed += morphTarget5 * morphTargetInfluences[ 5 ];\n\t\ttransformed += morphTarget6 * morphTargetInfluences[ 6 ];\n\t\ttransformed += morphTarget7 * morphTargetInfluences[ 7 ];\n\t#endif\n#endif'

  var normal_fragment_begin =
    '#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal );\n\t#ifdef DOUBLE_SIDED\n\t\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\t#ifdef USE_TANGENT\n\t\tvec3 tangent = normalize( vTangent );\n\t\tvec3 bitangent = normalize( vBitangent );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\ttangent = tangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t\tbitangent = bitangent * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\t#endif\n\t\t#if defined( TANGENTSPACE_NORMALMAP ) || defined( USE_CLEARCOAT_NORMALMAP )\n\t\t\tmat3 vTBN = mat3( tangent, bitangent, normal );\n\t\t#endif\n\t#endif\n#endif\nvec3 geometryNormal = normal;'

  var normal_fragment_maps =
    '#ifdef OBJECTSPACE_NORMALMAP\n\tnormal = texture2D( normalMap, vUv ).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 * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t#endif\n\tnormal = normalize( normalMatrix * normal );\n#elif defined( TANGENTSPACE_NORMALMAP )\n\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\tmapN.xy *= normalScale;\n\t#ifdef USE_TANGENT\n\t\tnormal = normalize( vTBN * mapN );\n\t#else\n\t\tnormal = perturbNormal2Arb( -vViewPosition, normal, mapN );\n\t#endif\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif'

  var normalmap_pars_fragment =
    '#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\n\tuniform mat3 normalMatrix;\n#endif\n#if ! defined ( USE_TANGENT ) && ( defined ( TANGENTSPACE_NORMALMAP ) || defined ( USE_CLEARCOAT_NORMALMAP ) )\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm, vec3 mapN ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tfloat scale = sign( st1.t * st0.s - st0.t * st1.s );\n\t\tvec3 S = normalize( ( q0 * st1.t - q1 * st0.t ) * scale );\n\t\tvec3 T = normalize( ( - q0 * st1.s + q1 * st0.s ) * scale );\n\t\tvec3 N = normalize( surf_norm );\n\t\tmat3 tsn = mat3( S, T, N );\n\t\tmapN.xy *= ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif'

  var clearcoat_normal_fragment_begin = '#ifdef CLEARCOAT\n\tvec3 clearcoatNormal = geometryNormal;\n#endif'

  var clearcoat_normal_fragment_maps =
    '#ifdef USE_CLEARCOAT_NORMALMAP\n\tvec3 clearcoatMapN = texture2D( clearcoatNormalMap, vUv ).xyz * 2.0 - 1.0;\n\tclearcoatMapN.xy *= clearcoatNormalScale;\n\t#ifdef USE_TANGENT\n\t\tclearcoatNormal = normalize( vTBN * clearcoatMapN );\n\t#else\n\t\tclearcoatNormal = perturbNormal2Arb( - vViewPosition, clearcoatNormal, clearcoatMapN );\n\t#endif\n#endif'

  var clearcoat_pars_fragment =
    '#ifdef USE_CLEARCOATMAP\n\tuniform sampler2D clearcoatMap;\n#endif\n#ifdef USE_CLEARCOAT_ROUGHNESSMAP\n\tuniform sampler2D clearcoatRoughnessMap;\n#endif\n#ifdef USE_CLEARCOAT_NORMALMAP\n\tuniform sampler2D clearcoatNormalMap;\n\tuniform vec2 clearcoatNormalScale;\n#endif'

  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.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nvec4 pack2HalfToRGBA( 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( 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 linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( 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 invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}'

  var premultiplied_alpha_fragment = '#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif'

  var project_vertex =
    'vec4 mvPosition = vec4( transformed, 1.0 );\n#ifdef USE_INSTANCING\n\tmvPosition = instanceMatrix * mvPosition;\n#endif\nmvPosition = modelViewMatrix * mvPosition;\ngl_Position = projectionMatrix * mvPosition;'

  var dithering_fragment = '#ifdef DITHERING\n\tgl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif'

  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 roughnessmap_fragment =
    'float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif'

  var roughnessmap_pars_fragment = '#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif'

  var shadowmap_pars_fragment =
    '#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 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\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\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 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 shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\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 shadow;\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 shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\n\t\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n\t\tvec3 lightToPosition = shadowCoord.xyz;\n\t\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\t\tdp += shadowBias;\n\t\tvec3 bd3D = normalize( lightToPosition );\n\t\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT ) || defined( SHADOWMAP_TYPE_VSM )\n\t\t\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n\t\t\treturn (\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n\t\t\t\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#else\n\t\t\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n\t\t#endif\n\t}\n#endif'

  var shadowmap_pars_vertex =
    '#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 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 mat4 spotShadowMatrix[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHT_SHADOWS ];\n\t\tstruct SpotLightShadow {\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 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 shadowmap_vertex =
    '#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHT_SHADOWS > 0 || NUM_SPOT_LIGHT_SHADOWS > 0 || NUM_POINT_LIGHT_SHADOWS > 0\n\t\tvec3 shadowWorldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\tvec4 shadowWorldPosition;\n\t#endif\n\t#if NUM_DIR_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_DIR_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * directionalLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_SPOT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_SPOT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * spotLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n\t#if NUM_POINT_LIGHT_SHADOWS > 0\n\t#pragma unroll_loop_start\n\tfor ( int i = 0; i < NUM_POINT_LIGHT_SHADOWS; i ++ ) {\n\t\tshadowWorldPosition = worldPosition + vec4( shadowWorldNormal * pointLightShadows[ i ].shadowNormalBias, 0 );\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * shadowWorldPosition;\n\t}\n\t#pragma unroll_loop_end\n\t#endif\n#endif'

  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.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.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ 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.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 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 skinning_pars_vertex =
    '#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform highp sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif'

  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 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 specularmap_fragment =
    'float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif'

  var specularmap_pars_fragment = '#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif'

  var tonemapping_fragment = '#if defined( TONE_MAPPING )\n\tgl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif'

  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 toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\nvec3 OptimizedCineonToneMapping( 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}\nvec3 CustomToneMapping( vec3 color ) { return color; }'

  var transmissionmap_fragment = '#ifdef USE_TRANSMISSIONMAP\n\ttotalTransmission *= texture2D( transmissionMap, vUv ).r;\n#endif'

  var transmissionmap_pars_fragment = '#ifdef USE_TRANSMISSIONMAP\n\tuniform sampler2D transmissionMap;\n#endif'

  var uv_pars_fragment = '#if ( defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ) )\n\tvarying vec2 vUv;\n#endif'

  var uv_pars_vertex = '#ifdef USE_UV\n\t#ifdef UVS_VERTEX_ONLY\n\t\tvec2 vUv;\n\t#else\n\t\tvarying vec2 vUv;\n\t#endif\n\tuniform mat3 uvTransform;\n#endif'

  var uv_vertex = '#ifdef USE_UV\n\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\n#endif'

  var uv2_pars_fragment = '#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif'

  var uv2_pars_vertex = '#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n\tuniform mat3 uv2Transform;\n#endif'

  var uv2_vertex = '#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;\n#endif'

  var worldpos_vertex =
    '#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = vec4( transformed, 1.0 );\n\t#ifdef USE_INSTANCING\n\t\tworldPosition = instanceMatrix * worldPosition;\n\t#endif\n\tworldPosition = modelMatrix * worldPosition;\n#endif'

  var background_frag =
    'uniform sampler2D t2D;\nvarying vec2 vUv;\nvoid main() {\n\tvec4 texColor = texture2D( t2D, vUv );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}'

  var background_vert =
    '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}'

  var cube_frag =
    '#include <envmap_common_pars_fragment>\nuniform float opacity;\nvarying vec3 vWorldDirection;\n#include <cube_uv_reflection_fragment>\nvoid main() {\n\tvec3 vReflect = vWorldDirection;\n\t#include <envmap_fragment>\n\tgl_FragColor = envColor;\n\tgl_FragColor.a *= opacity;\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}'

  var cube_vert =
    '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}'

  var depth_frag =
    '#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 <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvarying vec2 vHighPrecisionZW;\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\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 <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#endif\n}'

  var depth_vert =
    '#include <common>\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 <skinbase_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}'

  var distanceRGBA_frag =
    '#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 <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\tfloat dist = length( vWorldPosition - referencePosition );\n\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\n\tdist = saturate( dist );\n\tgl_FragColor = packDepthToRGBA( dist );\n}'

  var distanceRGBA_vert =
    '#define DISTANCE\nvarying vec3 vWorldPosition;\n#include <common>\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 <skinbase_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}'

  var equirect_frag =
    'uniform sampler2D tEquirect;\nvarying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldDirection );\n\tvec2 sampleUV = equirectUv( direction );\n\tvec4 texColor = texture2D( tEquirect, sampleUV );\n\tgl_FragColor = mapTexelToLinear( texColor );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n}'

  var equirect_vert =
    'varying vec3 vWorldDirection;\n#include <common>\nvoid main() {\n\tvWorldDirection = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}'

  var linedashed_frag =
    '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 <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}'

  var linedashed_vert =
    'uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\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>\nvoid main() {\n\tvLineDistance = scale * lineDistance;\n\t#include <color_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}'

  var meshbasic_frag =
    '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 <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_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 <cube_uv_reflection_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\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\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 <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\n\t\tvec4 lightMapTexel= texture2D( lightMap, vUv2 );\n\t\treflectedLight.indirectDiffuse += lightMapTexelToLinear( lightMapTexel ).rgb * lightMapIntensity;\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\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}'

  var meshbasic_vert =
    '#include <common>\n#include <uv_pars_vertex>\n#include <uv2_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 <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\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 <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}'

  var meshlambert_frag =
    'uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_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 <cube_uv_reflection_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\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 <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;\n\t#else\n\t\treflectedLight.indirectDiffuse += vIndirectFront;\n\t#endif\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}'

  var meshlambert_vert =
    '#define LAMBERT\nvarying vec3 vLightFront;\nvarying vec3 vIndirectFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n\tvarying vec3 vIndirectBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <color_pars_vertex>\n#include <fog_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 <uv2_vertex>\n\t#include <color_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 <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 <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}'

  var meshmatcap_frag =
    '#define MATCAP\nuniform vec3 diffuse;\nuniform float opacity;\nuniform sampler2D matcap;\nvarying vec3 vViewPosition;\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 <fog_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\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\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 <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\tmatcapColor = matcapTexelToLinear( matcapColor );\n\t#else\n\t\tvec4 matcapColor = vec4( 1.0 );\n\t#endif\n\tvec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}'

  var meshmatcap_vert =
    '#define MATCAP\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <color_pars_vertex>\n#include <displacementmap_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 <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#ifndef FLAT_SHADED\n\t\tvNormal = normalize( transformedNormal );\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\t#include <fog_vertex>\n\tvViewPosition = - mvPosition.xyz;\n}'

  var meshtoon_frag =
    '#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 <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_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 <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\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\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 <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\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}'

  var meshtoon_vert =
    '#define TOON\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_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 <uv2_vertex>\n\t#include <color_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#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#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\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}'

  var meshphong_frag =
    '#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 <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_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 <cube_uv_reflection_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\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\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\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 <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\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}'

  var meshphong_vert =
    '#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_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 <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_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#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#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\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}'

  var meshphysical_frag =
    '#define STANDARD\n#ifdef PHYSICAL\n\t#define REFLECTIVITY\n\t#define CLEARCOAT\n\t#define TRANSMISSION\n#endif\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifdef TRANSMISSION\n\tuniform float transmission;\n#endif\n#ifdef REFLECTIVITY\n\tuniform float reflectivity;\n#endif\n#ifdef CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n#ifdef USE_SHEEN\n\tuniform vec3 sheen;\n#endif\nvarying vec3 vViewPosition;\n#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\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <transmissionmap_pars_fragment>\n#include <bsdfs>\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 <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_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\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#ifdef TRANSMISSION\n\t\tfloat totalTransmission = transmission;\n\t#endif\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 <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 <transmissionmap_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 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#ifdef TRANSMISSION\n\t\tdiffuseColor.a *= mix( saturate( 1. - totalTransmission + linearToRelativeLuminance( reflectedLight.directSpecular + reflectedLight.indirectSpecular ) ), 1.0, metalness );\n\t#endif\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}'

  var meshphysical_vert =
    '#define STANDARD\nvarying vec3 vViewPosition;\n#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\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_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 <uv2_vertex>\n\t#include <color_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#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\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}'

  var normal_frag =
    '#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#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\n#include <packing>\n#include <uv_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\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 ), opacity );\n}'

  var normal_vert =
    '#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( TANGENTSPACE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#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\n#include <common>\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>\nvoid main() {\n\t#include <uv_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#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\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( TANGENTSPACE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}'

  var points_frag =
    'uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n}'

  var points_vert =
    '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>\nvoid main() {\n\t#include <color_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}'

  var shadow_frag =
    '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 <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}'

  var shadow_vert =
    '#include <common>\n#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_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 <shadowmap_vertex>\n\t#include <fog_vertex>\n}'

  var sprite_frag =
    '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 <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}'

  var sprite_vert =
    '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 * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\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}'

  var ShaderChunk = {
    alphamap_fragment: alphamap_fragment,
    alphamap_pars_fragment: alphamap_pars_fragment,
    alphatest_fragment: alphatest_fragment,
    aomap_fragment: aomap_fragment,
    aomap_pars_fragment: aomap_pars_fragment,
    begin_vertex: begin_vertex,
    beginnormal_vertex: beginnormal_vertex,
    bsdfs: bsdfs,
    bumpmap_pars_fragment: bumpmap_pars_fragment,
    clipping_planes_fragment: clipping_planes_fragment,
    clipping_planes_pars_fragment: clipping_planes_pars_fragment,
    clipping_planes_pars_vertex: clipping_planes_pars_vertex,
    clipping_planes_vertex: clipping_planes_vertex,
    color_fragment: color_fragment,
    color_pars_fragment: color_pars_fragment,
    color_pars_vertex: color_pars_vertex,
    color_vertex: color_vertex,
    common: common,
    cube_uv_reflection_fragment: cube_uv_reflection_fragment,
    defaultnormal_vertex: defaultnormal_vertex,
    displacementmap_pars_vertex: displacementmap_pars_vertex,
    displacementmap_vertex: displacementmap_vertex,
    emissivemap_fragment: emissivemap_fragment,
    emissivemap_pars_fragment: emissivemap_pars_fragment,
    encodings_fragment: encodings_fragment,
    encodings_pars_fragment: encodings_pars_fragment,
    envmap_fragment: envmap_fragment,
    envmap_common_pars_fragment: envmap_common_pars_fragment,
    envmap_pars_fragment: envmap_pars_fragment,
    envmap_pars_vertex: envmap_pars_vertex,
    envmap_physical_pars_fragment: envmap_physical_pars_fragment,
    envmap_vertex: envmap_vertex,
    fog_vertex: fog_vertex,
    fog_pars_vertex: fog_pars_vertex,
    fog_fragment: fog_fragment,
    fog_pars_fragment: fog_pars_fragment,
    gradientmap_pars_fragment: gradientmap_pars_fragment,
    lightmap_fragment: lightmap_fragment,
    lightmap_pars_fragment: lightmap_pars_fragment,
    lights_lambert_vertex: lights_lambert_vertex,
    lights_pars_begin: lights_pars_begin,
    lights_toon_fragment: lights_toon_fragment,
    lights_toon_pars_fragment: lights_toon_pars_fragment,
    lights_phong_fragment: lights_phong_fragment,
    lights_phong_pars_fragment: lights_phong_pars_fragment,
    lights_physical_fragment: lights_physical_fragment,
    lights_physical_pars_fragment: lights_physical_pars_fragment,
    lights_fragment_begin: lights_fragment_begin,
    lights_fragment_maps: lights_fragment_maps,
    lights_fragment_end: lights_fragment_end,
    logdepthbuf_fragment: logdepthbuf_fragment,
    logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
    logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
    logdepthbuf_vertex: logdepthbuf_vertex,
    map_fragment: map_fragment,
    map_pars_fragment: map_pars_fragment,
    map_particle_fragment: map_particle_fragment,
    map_particle_pars_fragment: map_particle_pars_fragment,
    metalnessmap_fragment: metalnessmap_fragment,
    metalnessmap_pars_fragment: metalnessmap_pars_fragment,
    morphnormal_vertex: morphnormal_vertex,
    morphtarget_pars_vertex: morphtarget_pars_vertex,
    morphtarget_vertex: morphtarget_vertex,
    normal_fragment_begin: normal_fragment_begin,
    normal_fragment_maps: normal_fragment_maps,
    normalmap_pars_fragment: normalmap_pars_fragment,
    clearcoat_normal_fragment_begin: clearcoat_normal_fragment_begin,
    clearcoat_normal_fragment_maps: clearcoat_normal_fragment_maps,
    clearcoat_pars_fragment: clearcoat_pars_fragment,
    packing: packing,
    premultiplied_alpha_fragment: premultiplied_alpha_fragment,
    project_vertex: project_vertex,
    dithering_fragment: dithering_fragment,
    dithering_pars_fragment: dithering_pars_fragment,
    roughnessmap_fragment: roughnessmap_fragment,
    roughnessmap_pars_fragment: roughnessmap_pars_fragment,
    shadowmap_pars_fragment: shadowmap_pars_fragment,
    shadowmap_pars_vertex: shadowmap_pars_vertex,
    shadowmap_vertex: shadowmap_vertex,
    shadowmask_pars_fragment: shadowmask_pars_fragment,
    skinbase_vertex: skinbase_vertex,
    skinning_pars_vertex: skinning_pars_vertex,
    skinning_vertex: skinning_vertex,
    skinnormal_vertex: skinnormal_vertex,
    specularmap_fragment: specularmap_fragment,
    specularmap_pars_fragment: specularmap_pars_fragment,
    tonemapping_fragment: tonemapping_fragment,
    tonemapping_pars_fragment: tonemapping_pars_fragment,
    transmissionmap_fragment: transmissionmap_fragment,
    transmissionmap_pars_fragment: transmissionmap_pars_fragment,
    uv_pars_fragment: uv_pars_fragment,
    uv_pars_vertex: uv_pars_vertex,
    uv_vertex: uv_vertex,
    uv2_pars_fragment: uv2_pars_fragment,
    uv2_pars_vertex: uv2_pars_vertex,
    uv2_vertex: uv2_vertex,
    worldpos_vertex: worldpos_vertex,
    background_frag: background_frag,
    background_vert: background_vert,
    cube_frag: cube_frag,
    cube_vert: cube_vert,
    depth_frag: depth_frag,
    depth_vert: depth_vert,
    distanceRGBA_frag: distanceRGBA_frag,
    distanceRGBA_vert: distanceRGBA_vert,
    equirect_frag: equirect_frag,
    equirect_vert: equirect_vert,
    linedashed_frag: linedashed_frag,
    linedashed_vert: linedashed_vert,
    meshbasic_frag: meshbasic_frag,
    meshbasic_vert: meshbasic_vert,
    meshlambert_frag: meshlambert_frag,
    meshlambert_vert: meshlambert_vert,
    meshmatcap_frag: meshmatcap_frag,
    meshmatcap_vert: meshmatcap_vert,
    meshtoon_frag: meshtoon_frag,
    meshtoon_vert: meshtoon_vert,
    meshphong_frag: meshphong_frag,
    meshphong_vert: meshphong_vert,
    meshphysical_frag: meshphysical_frag,
    meshphysical_vert: meshphysical_vert,
    normal_frag: normal_frag,
    normal_vert: normal_vert,
    points_frag: points_frag,
    points_vert: points_vert,
    shadow_frag: shadow_frag,
    shadow_vert: shadow_vert,
    sprite_frag: sprite_frag,
    sprite_vert: sprite_vert
  }

  /**
   * Uniforms library for shared webgl shaders
   */

  var UniformsLib = {
    common: {
      diffuse: {
        value: new Color(0xeeeeee)
      },
      opacity: {
        value: 1.0
      },
      map: {
        value: null
      },
      uvTransform: {
        value: new Matrix3()
      },
      uv2Transform: {
        value: new Matrix3()
      },
      alphaMap: {
        value: null
      }
    },
    specularmap: {
      specularMap: {
        value: null
      }
    },
    envmap: {
      envMap: {
        value: null
      },
      flipEnvMap: {
        value: -1
      },
      reflectivity: {
        value: 1.0
      },
      refractionRatio: {
        value: 0.98
      },
      maxMipLevel: {
        value: 0
      }
    },
    aomap: {
      aoMap: {
        value: null
      },
      aoMapIntensity: {
        value: 1
      }
    },
    lightmap: {
      lightMap: {
        value: null
      },
      lightMapIntensity: {
        value: 1
      }
    },
    emissivemap: {
      emissiveMap: {
        value: null
      }
    },
    bumpmap: {
      bumpMap: {
        value: null
      },
      bumpScale: {
        value: 1
      }
    },
    normalmap: {
      normalMap: {
        value: null
      },
      normalScale: {
        value: new Vector2(1, 1)
      }
    },
    displacementmap: {
      displacementMap: {
        value: null
      },
      displacementScale: {
        value: 1
      },
      displacementBias: {
        value: 0
      }
    },
    roughnessmap: {
      roughnessMap: {
        value: null
      }
    },
    metalnessmap: {
      metalnessMap: {
        value: null
      }
    },
    gradientmap: {
      gradientMap: {
        value: null
      }
    },
    fog: {
      fogDensity: {
        value: 0.00025
      },
      fogNear: {
        value: 1
      },
      fogFar: {
        value: 2000
      },
      fogColor: {
        value: new Color(0xffffff)
      }
    },
    lights: {
      ambientLightColor: {
        value: []
      },
      lightProbe: {
        value: []
      },
      directionalLights: {
        value: [],
        properties: {
          direction: {},
          color: {}
        }
      },
      directionalLightShadows: {
        value: [],
        properties: {
          shadowBias: {},
          shadowNormalBias: {},
          shadowRadius: {},
          shadowMapSize: {}
        }
      },
      directionalShadowMap: {
        value: []
      },
      directionalShadowMatrix: {
        value: []
      },
      spotLights: {
        value: [],
        properties: {
          color: {},
          position: {},
          direction: {},
          distance: {},
          coneCos: {},
          penumbraCos: {},
          decay: {}
        }
      },
      spotLightShadows: {
        value: [],
        properties: {
          shadowBias: {},
          shadowNormalBias: {},
          shadowRadius: {},
          shadowMapSize: {}
        }
      },
      spotShadowMap: {
        value: []
      },
      spotShadowMatrix: {
        value: []
      },
      pointLights: {
        value: [],
        properties: {
          color: {},
          position: {},
          decay: {},
          distance: {}
        }
      },
      pointLightShadows: {
        value: [],
        properties: {
          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: new Color(0xeeeeee)
      },
      opacity: {
        value: 1.0
      },
      size: {
        value: 1.0
      },
      scale: {
        value: 1.0
      },
      map: {
        value: null
      },
      alphaMap: {
        value: null
      },
      uvTransform: {
        value: new Matrix3()
      }
    },
    sprite: {
      diffuse: {
        value: new Color(0xeeeeee)
      },
      opacity: {
        value: 1.0
      },
      center: {
        value: new Vector2(0.5, 0.5)
      },
      rotation: {
        value: 0.0
      },
      map: {
        value: null
      },
      alphaMap: {
        value: null
      },
      uvTransform: {
        value: new Matrix3()
      }
    }
  }

  var ShaderLib = {
    basic: {
      uniforms: mergeUniforms([UniformsLib.common, UniformsLib.specularmap, UniformsLib.envmap, UniformsLib.aomap, UniformsLib.lightmap, UniformsLib.fog]),
      vertexShader: ShaderChunk.meshbasic_vert,
      fragmentShader: ShaderChunk.meshbasic_frag
    },
    lambert: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.specularmap,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: {
            value: new Color(0x000000)
          }
        }
      ]),
      vertexShader: ShaderChunk.meshlambert_vert,
      fragmentShader: ShaderChunk.meshlambert_frag
    },
    phong: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.specularmap,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: {
            value: new Color(0x000000)
          },
          specular: {
            value: new Color(0x111111)
          },
          shininess: {
            value: 30
          }
        }
      ]),
      vertexShader: ShaderChunk.meshphong_vert,
      fragmentShader: ShaderChunk.meshphong_frag
    },
    standard: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.envmap,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        UniformsLib.roughnessmap,
        UniformsLib.metalnessmap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: {
            value: new Color(0x000000)
          },
          roughness: {
            value: 1.0
          },
          metalness: {
            value: 0.0
          },
          envMapIntensity: {
            value: 1
          } // temporary
        }
      ]),
      vertexShader: ShaderChunk.meshphysical_vert,
      fragmentShader: ShaderChunk.meshphysical_frag
    },
    toon: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.aomap,
        UniformsLib.lightmap,
        UniformsLib.emissivemap,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        UniformsLib.gradientmap,
        UniformsLib.fog,
        UniformsLib.lights,
        {
          emissive: {
            value: new Color(0x000000)
          }
        }
      ]),
      vertexShader: ShaderChunk.meshtoon_vert,
      fragmentShader: ShaderChunk.meshtoon_frag
    },
    matcap: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        UniformsLib.fog,
        {
          matcap: {
            value: null
          }
        }
      ]),
      vertexShader: ShaderChunk.meshmatcap_vert,
      fragmentShader: ShaderChunk.meshmatcap_frag
    },
    points: {
      uniforms: mergeUniforms([UniformsLib.points, UniformsLib.fog]),
      vertexShader: ShaderChunk.points_vert,
      fragmentShader: ShaderChunk.points_frag
    },
    dashed: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.fog,
        {
          scale: {
            value: 1
          },
          dashSize: {
            value: 1
          },
          totalSize: {
            value: 2
          }
        }
      ]),
      vertexShader: ShaderChunk.linedashed_vert,
      fragmentShader: ShaderChunk.linedashed_frag
    },
    depth: {
      uniforms: mergeUniforms([UniformsLib.common, UniformsLib.displacementmap]),
      vertexShader: ShaderChunk.depth_vert,
      fragmentShader: ShaderChunk.depth_frag
    },
    normal: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.bumpmap,
        UniformsLib.normalmap,
        UniformsLib.displacementmap,
        {
          opacity: {
            value: 1.0
          }
        }
      ]),
      vertexShader: ShaderChunk.normal_vert,
      fragmentShader: ShaderChunk.normal_frag
    },
    sprite: {
      uniforms: mergeUniforms([UniformsLib.sprite, UniformsLib.fog]),
      vertexShader: ShaderChunk.sprite_vert,
      fragmentShader: ShaderChunk.sprite_frag
    },
    background: {
      uniforms: {
        uvTransform: {
          value: new Matrix3()
        },
        t2D: {
          value: null
        }
      },
      vertexShader: ShaderChunk.background_vert,
      fragmentShader: ShaderChunk.background_frag
    },

    /* -------------------------------------------------------------------------
		//	Cube map shader
		 ------------------------------------------------------------------------- */
    cube: {
      uniforms: mergeUniforms([
        UniformsLib.envmap,
        {
          opacity: {
            value: 1.0
          }
        }
      ]),
      vertexShader: ShaderChunk.cube_vert,
      fragmentShader: ShaderChunk.cube_frag
    },
    equirect: {
      uniforms: {
        tEquirect: {
          value: null
        }
      },
      vertexShader: ShaderChunk.equirect_vert,
      fragmentShader: ShaderChunk.equirect_frag
    },
    distanceRGBA: {
      uniforms: mergeUniforms([
        UniformsLib.common,
        UniformsLib.displacementmap,
        {
          referencePosition: {
            value: new Vector3()
          },
          nearDistance: {
            value: 1
          },
          farDistance: {
            value: 1000
          }
        }
      ]),
      vertexShader: ShaderChunk.distanceRGBA_vert,
      fragmentShader: ShaderChunk.distanceRGBA_frag
    },
    shadow: {
      uniforms: mergeUniforms([
        UniformsLib.lights,
        UniformsLib.fog,
        {
          color: {
            value: new Color(0x00000)
          },
          opacity: {
            value: 1.0
          }
        }
      ]),
      vertexShader: ShaderChunk.shadow_vert,
      fragmentShader: ShaderChunk.shadow_frag
    }
  }
  ShaderLib.physical = {
    uniforms: mergeUniforms([
      ShaderLib.standard.uniforms,
      {
        clearcoat: {
          value: 0
        },
        clearcoatMap: {
          value: null
        },
        clearcoatRoughness: {
          value: 0
        },
        clearcoatRoughnessMap: {
          value: null
        },
        clearcoatNormalScale: {
          value: new Vector2(1, 1)
        },
        clearcoatNormalMap: {
          value: null
        },
        sheen: {
          value: new Color(0x000000)
        },
        transmission: {
          value: 0
        },
        transmissionMap: {
          value: null
        }
      }
    ]),
    vertexShader: ShaderChunk.meshphysical_vert,
    fragmentShader: ShaderChunk.meshphysical_frag
  }

  function WebGLBackground(renderer, cubemaps, state, objects, premultipliedAlpha) {
    var clearColor = new Color(0x000000)
    var clearAlpha = 0
    var planeMesh
    var boxMesh
    var currentBackground = null
    var currentBackgroundVersion = 0
    var currentTonemapping = null

    function render(renderList, scene, camera, forceClear) {
      var background = scene.isScene === true ? scene.background : null

      if (background && background.isTexture) {
        background = cubemaps.get(background)
      } // Ignore background in AR
      // TODO: Reconsider this.

      var xr = renderer.xr
      var session = xr.getSession && xr.getSession()

      if (session && session.environmentBlendMode === 'additive') {
        background = null
      }

      if (background === null) {
        setClear(clearColor, clearAlpha)
      } else if (background && background.isColor) {
        setClear(background, 1)
        forceClear = true
      }

      if (renderer.autoClear || forceClear) {
        renderer.clear(renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil)
      }

      if (background && (background.isCubeTexture || background.isWebGLCubeRenderTarget || background.mapping === CubeUVReflectionMapping)) {
        if (boxMesh === undefined) {
          boxMesh = new Mesh(
            new BoxBufferGeometry(1, 1, 1),
            new ShaderMaterial({
              name: 'BackgroundCubeMaterial',
              uniforms: cloneUniforms(ShaderLib.cube.uniforms),
              vertexShader: ShaderLib.cube.vertexShader,
              fragmentShader: ShaderLib.cube.fragmentShader,
              side: BackSide,
              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)
          } // enable code injection for non-built-in material

          Object.defineProperty(boxMesh.material, 'envMap', {
            get: function get() {
              return this.uniforms.envMap.value
            }
          })
          objects.update(boxMesh)
        }

        if (background.isWebGLCubeRenderTarget) {
          // TODO Deprecate
          background = background.texture
        }

        boxMesh.material.uniforms.envMap.value = background
        boxMesh.material.uniforms.flipEnvMap.value = background.isCubeTexture && background._needsFlipEnvMap ? -1 : 1

        if (currentBackground !== background || currentBackgroundVersion !== background.version || currentTonemapping !== renderer.toneMapping) {
          boxMesh.material.needsUpdate = true
          currentBackground = background
          currentBackgroundVersion = background.version
          currentTonemapping = renderer.toneMapping
        } // 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 Mesh(
            new PlaneBufferGeometry(2, 2),
            new ShaderMaterial({
              name: 'BackgroundMaterial',
              uniforms: cloneUniforms(ShaderLib.background.uniforms),
              vertexShader: ShaderLib.background.vertexShader,
              fragmentShader: ShaderLib.background.fragmentShader,
              side: FrontSide,
              depthTest: false,
              depthWrite: false,
              fog: false
            })
          )
          planeMesh.geometry.deleteAttribute('normal') // enable code injection for non-built-in material

          Object.defineProperty(planeMesh.material, 'map', {
            get: function get() {
              return this.uniforms.t2D.value
            }
          })
          objects.update(planeMesh)
        }

        planeMesh.material.uniforms.t2D.value = background

        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
        } // push to the pre-sorted opaque render list

        renderList.unshift(planeMesh, planeMesh.geometry, planeMesh.material, 0, 0, null)
      }
    }

    function setClear(color, alpha) {
      state.buffers.color.setClear(color.r, color.g, color.b, alpha, premultipliedAlpha)
    }

    return {
      getClearColor: function getClearColor() {
        return clearColor
      },
      setClearColor: function setClearColor(color, alpha) {
        if (alpha === void 0) {
          alpha = 1
        }

        clearColor.set(color)
        clearAlpha = alpha
        setClear(clearColor, clearAlpha)
      },
      getClearAlpha: function getClearAlpha() {
        return clearAlpha
      },
      setClearAlpha: function setClearAlpha(alpha) {
        clearAlpha = alpha
        setClear(clearColor, clearAlpha)
      },
      render: render
    }
  }

  function WebGLBindingStates(gl, extensions, attributes, capabilities) {
    var maxVertexAttributes = gl.getParameter(34921)
    var extension = capabilities.isWebGL2 ? null : extensions.get('OES_vertex_array_object')
    var vaoAvailable = capabilities.isWebGL2 || extension !== null
    var bindingStates = {}
    var defaultState = createBindingState(null)
    var currentState = defaultState

    function setup(object, material, program, geometry, index) {
      var updateBuffers = false

      if (vaoAvailable) {
        var state = getBindingState(geometry, program, material)

        if (currentState !== state) {
          currentState = state
          bindVertexArrayObject(currentState.object)
        }

        updateBuffers = needsUpdate(geometry, index)
        if (updateBuffers) saveCache(geometry, index)
      } else {
        var wireframe = material.wireframe === true

        if (currentState.geometry !== geometry.id || currentState.program !== program.id || currentState.wireframe !== wireframe) {
          currentState.geometry = geometry.id
          currentState.program = program.id
          currentState.wireframe = wireframe
          updateBuffers = true
        }
      }

      if (object.isInstancedMesh === true) {
        updateBuffers = true
      }

      if (index !== null) {
        attributes.update(index, 34963)
      }

      if (updateBuffers) {
        setupVertexAttributes(object, material, program, geometry)

        if (index !== null) {
          gl.bindBuffer(34963, attributes.get(index).buffer)
        }
      }
    }

    function createVertexArrayObject() {
      if (capabilities.isWebGL2) return gl.createVertexArray()
      return extension.createVertexArrayOES()
    }

    function bindVertexArrayObject(vao) {
      if (capabilities.isWebGL2) return gl.bindVertexArray(vao)
      return extension.bindVertexArrayOES(vao)
    }

    function deleteVertexArrayObject(vao) {
      if (capabilities.isWebGL2) return gl.deleteVertexArray(vao)
      return extension.deleteVertexArrayOES(vao)
    }

    function getBindingState(geometry, program, material) {
      var wireframe = material.wireframe === true
      var programMap = bindingStates[geometry.id]

      if (programMap === undefined) {
        programMap = {}
        bindingStates[geometry.id] = programMap
      }

      var stateMap = programMap[program.id]

      if (stateMap === undefined) {
        stateMap = {}
        programMap[program.id] = stateMap
      }

      var state = stateMap[wireframe]

      if (state === undefined) {
        state = createBindingState(createVertexArrayObject())
        stateMap[wireframe] = state
      }

      return state
    }

    function createBindingState(vao) {
      var newAttributes = []
      var enabledAttributes = []
      var attributeDivisors = []

      for (var 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(geometry, index) {
      var cachedAttributes = currentState.attributes
      var geometryAttributes = geometry.attributes
      var attributesNum = 0

      for (var key in geometryAttributes) {
        var cachedAttribute = cachedAttributes[key]
        var geometryAttribute = geometryAttributes[key]
        if (cachedAttribute === undefined) return true
        if (cachedAttribute.attribute !== geometryAttribute) return true
        if (cachedAttribute.data !== geometryAttribute.data) return true
        attributesNum++
      }

      if (currentState.attributesNum !== attributesNum) return true
      if (currentState.index !== index) return true
      return false
    }

    function saveCache(geometry, index) {
      var cache = {}
      var attributes = geometry.attributes
      var attributesNum = 0

      for (var key in attributes) {
        var attribute = attributes[key]
        var data = {}
        data.attribute = attribute

        if (attribute.data) {
          data.data = attribute.data
        }

        cache[key] = data
        attributesNum++
      }

      currentState.attributes = cache
      currentState.attributesNum = attributesNum
      currentState.index = index
    }

    function initAttributes() {
      var newAttributes = currentState.newAttributes

      for (var i = 0, il = newAttributes.length; i < il; i++) {
        newAttributes[i] = 0
      }
    }

    function enableAttribute(attribute) {
      enableAttributeAndDivisor(attribute, 0)
    }

    function enableAttributeAndDivisor(attribute, meshPerAttribute) {
      var newAttributes = currentState.newAttributes
      var enabledAttributes = currentState.enabledAttributes
      var attributeDivisors = currentState.attributeDivisors
      newAttributes[attribute] = 1

      if (enabledAttributes[attribute] === 0) {
        gl.enableVertexAttribArray(attribute)
        enabledAttributes[attribute] = 1
      }

      if (attributeDivisors[attribute] !== meshPerAttribute) {
        var _extension = capabilities.isWebGL2 ? gl : extensions.get('ANGLE_instanced_arrays')

        _extension[capabilities.isWebGL2 ? 'vertexAttribDivisor' : 'vertexAttribDivisorANGLE'](attribute, meshPerAttribute)

        attributeDivisors[attribute] = meshPerAttribute
      }
    }

    function disableUnusedAttributes() {
      var newAttributes = currentState.newAttributes
      var enabledAttributes = currentState.enabledAttributes

      for (var 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) {
      if (capabilities.isWebGL2 === true && (type === 5124 || type === 5125)) {
        gl.vertexAttribIPointer(index, size, type, stride, offset)
      } else {
        gl.vertexAttribPointer(index, size, type, normalized, stride, offset)
      }
    }

    function setupVertexAttributes(object, material, program, geometry) {
      if (capabilities.isWebGL2 === false && (object.isInstancedMesh || geometry.isInstancedBufferGeometry)) {
        if (extensions.get('ANGLE_instanced_arrays') === null) return
      }

      initAttributes()
      var geometryAttributes = geometry.attributes
      var programAttributes = program.getAttributes()
      var materialDefaultAttributeValues = material.defaultAttributeValues

      for (var name in programAttributes) {
        var programAttribute = programAttributes[name]

        if (programAttribute >= 0) {
          var geometryAttribute = geometryAttributes[name]

          if (geometryAttribute !== undefined) {
            var normalized = geometryAttribute.normalized
            var size = geometryAttribute.itemSize
            var attribute = attributes.get(geometryAttribute) // TODO Attribute may not be available on context restore

            if (attribute === undefined) continue
            var buffer = attribute.buffer
            var type = attribute.type
            var bytesPerElement = attribute.bytesPerElement

            if (geometryAttribute.isInterleavedBufferAttribute) {
              var data = geometryAttribute.data
              var stride = data.stride
              var offset = geometryAttribute.offset

              if (data && data.isInstancedInterleavedBuffer) {
                enableAttributeAndDivisor(programAttribute, data.meshPerAttribute)

                if (geometry._maxInstanceCount === undefined) {
                  geometry._maxInstanceCount = data.meshPerAttribute * data.count
                }
              } else {
                enableAttribute(programAttribute)
              }

              gl.bindBuffer(34962, buffer)
              vertexAttribPointer(programAttribute, size, type, normalized, stride * bytesPerElement, offset * bytesPerElement)
            } else {
              if (geometryAttribute.isInstancedBufferAttribute) {
                enableAttributeAndDivisor(programAttribute, geometryAttribute.meshPerAttribute)

                if (geometry._maxInstanceCount === undefined) {
                  geometry._maxInstanceCount = geometryAttribute.meshPerAttribute * geometryAttribute.count
                }
              } else {
                enableAttribute(programAttribute)
              }

              gl.bindBuffer(34962, buffer)
              vertexAttribPointer(programAttribute, size, type, normalized, 0, 0)
            }
          } else if (name === 'instanceMatrix') {
            var _attribute = attributes.get(object.instanceMatrix) // TODO Attribute may not be available on context restore

            if (_attribute === undefined) continue
            var _buffer = _attribute.buffer
            var _type = _attribute.type
            enableAttributeAndDivisor(programAttribute + 0, 1)
            enableAttributeAndDivisor(programAttribute + 1, 1)
            enableAttributeAndDivisor(programAttribute + 2, 1)
            enableAttributeAndDivisor(programAttribute + 3, 1)
            gl.bindBuffer(34962, _buffer)
            gl.vertexAttribPointer(programAttribute + 0, 4, _type, false, 64, 0)
            gl.vertexAttribPointer(programAttribute + 1, 4, _type, false, 64, 16)
            gl.vertexAttribPointer(programAttribute + 2, 4, _type, false, 64, 32)
            gl.vertexAttribPointer(programAttribute + 3, 4, _type, false, 64, 48)
          } else if (name === 'instanceColor') {
            var _attribute2 = attributes.get(object.instanceColor) // TODO Attribute may not be available on context restore

            if (_attribute2 === undefined) continue
            var _buffer2 = _attribute2.buffer
            var _type2 = _attribute2.type
            enableAttributeAndDivisor(programAttribute, 1)
            gl.bindBuffer(34962, _buffer2)
            gl.vertexAttribPointer(programAttribute, 3, _type2, false, 12, 0)
          } else if (materialDefaultAttributeValues !== undefined) {
            var value = materialDefaultAttributeValues[name]

            if (value !== undefined) {
              switch (value.length) {
                case 2:
                  gl.vertexAttrib2fv(programAttribute, value)
                  break

                case 3:
                  gl.vertexAttrib3fv(programAttribute, value)
                  break

                case 4:
                  gl.vertexAttrib4fv(programAttribute, value)
                  break

                default:
                  gl.vertexAttrib1fv(programAttribute, value)
              }
            }
          }
        }
      }

      disableUnusedAttributes()
    }

    function dispose() {
      reset()

      for (var geometryId in bindingStates) {
        var programMap = bindingStates[geometryId]

        for (var programId in programMap) {
          var stateMap = programMap[programId]

          for (var 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
      var programMap = bindingStates[geometry.id]

      for (var programId in programMap) {
        var stateMap = programMap[programId]

        for (var wireframe in stateMap) {
          deleteVertexArrayObject(stateMap[wireframe].object)
          delete stateMap[wireframe]
        }

        delete programMap[programId]
      }

      delete bindingStates[geometry.id]
    }

    function releaseStatesOfProgram(program) {
      for (var geometryId in bindingStates) {
        var programMap = bindingStates[geometryId]
        if (programMap[program.id] === undefined) continue
        var stateMap = programMap[program.id]

        for (var wireframe in stateMap) {
          deleteVertexArrayObject(stateMap[wireframe].object)
          delete stateMap[wireframe]
        }

        delete programMap[program.id]
      }
    }

    function reset() {
      resetDefaultState()
      if (currentState === defaultState) return
      currentState = defaultState
      bindVertexArrayObject(currentState.object)
    } // for backward-compatilibity

    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 WebGLBufferRenderer(gl, extensions, info, capabilities) {
    var isWebGL2 = capabilities.isWebGL2
    var 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
      var extension, methodName

      if (isWebGL2) {
        extension = gl
        methodName = 'drawArraysInstanced'
      } else {
        extension = extensions.get('ANGLE_instanced_arrays')
        methodName = 'drawArraysInstancedANGLE'

        if (extension === null) {
          console.error('THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.')
          return
        }
      }

      extension[methodName](mode, start, count, primcount)
      info.update(count, mode, primcount)
    } //

    this.setMode = setMode
    this.render = render
    this.renderInstances = renderInstances
  }

  function WebGLCapabilities(gl, extensions, parameters) {
    var maxAnisotropy

    function getMaxAnisotropy() {
      if (maxAnisotropy !== undefined) return maxAnisotropy
      var extension = extensions.get('EXT_texture_filter_anisotropic')

      if (extension !== null) {
        maxAnisotropy = gl.getParameter(extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT)
      } else {
        maxAnisotropy = 0
      }

      return maxAnisotropy
    }

    function getMaxPrecision(precision) {
      if (precision === 'highp') {
        if (gl.getShaderPrecisionFormat(35633, 36338).precision > 0 && gl.getShaderPrecisionFormat(35632, 36338).precision > 0) {
          return 'highp'
        }

        precision = 'mediump'
      }

      if (precision === 'mediump') {
        if (gl.getShaderPrecisionFormat(35633, 36337).precision > 0 && gl.getShaderPrecisionFormat(35632, 36337).precision > 0) {
          return 'mediump'
        }
      }

      return 'lowp'
    }
    /* eslint-disable no-undef */

    var isWebGL2 =
      (typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext) ||
      (typeof WebGL2ComputeRenderingContext !== 'undefined' && gl instanceof WebGL2ComputeRenderingContext)
    /* eslint-enable no-undef */

    var precision = parameters.precision !== undefined ? parameters.precision : 'highp'
    var maxPrecision = getMaxPrecision(precision)

    if (maxPrecision !== precision) {
      console.warn('THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.')
      precision = maxPrecision
    }

    var logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true
    var maxTextures = gl.getParameter(34930)
    var maxVertexTextures = gl.getParameter(35660)
    var maxTextureSize = gl.getParameter(3379)
    var maxCubemapSize = gl.getParameter(34076)
    var maxAttributes = gl.getParameter(34921)
    var maxVertexUniforms = gl.getParameter(36347)
    var maxVaryings = gl.getParameter(36348)
    var maxFragmentUniforms = gl.getParameter(36349)
    var vertexTextures = maxVertexTextures > 0
    var floatFragmentTextures = isWebGL2 || !!extensions.get('OES_texture_float')
    var floatVertexTextures = vertexTextures && floatFragmentTextures
    var maxSamples = isWebGL2 ? gl.getParameter(36183) : 0
    return {
      isWebGL2: isWebGL2,
      getMaxAnisotropy: getMaxAnisotropy,
      getMaxPrecision: getMaxPrecision,
      precision: precision,
      logarithmicDepthBuffer: logarithmicDepthBuffer,
      maxTextures: maxTextures,
      maxVertexTextures: maxVertexTextures,
      maxTextureSize: maxTextureSize,
      maxCubemapSize: maxCubemapSize,
      maxAttributes: maxAttributes,
      maxVertexUniforms: maxVertexUniforms,
      maxVaryings: maxVaryings,
      maxFragmentUniforms: maxFragmentUniforms,
      vertexTextures: vertexTextures,
      floatFragmentTextures: floatFragmentTextures,
      floatVertexTextures: floatVertexTextures,
      maxSamples: maxSamples
    }
  }

  function WebGLClipping(properties) {
    var scope = this
    var globalState = null,
      numGlobalPlanes = 0,
      localClippingEnabled = false,
      renderingShadows = false
    var plane = new Plane(),
      viewNormalMatrix = new Matrix3(),
      uniform = {
        value: null,
        needsUpdate: false
      }
    this.uniform = uniform
    this.numPlanes = 0
    this.numIntersection = 0

    this.init = function (planes, enableLocalClipping, camera) {
      var 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
      globalState = projectPlanes(planes, camera, 0)
      numGlobalPlanes = planes.length
      return enabled
    }

    this.beginShadows = function () {
      renderingShadows = true
      projectPlanes(null)
    }

    this.endShadows = function () {
      renderingShadows = false
      resetGlobalState()
    }

    this.setState = function (material, camera, useCache) {
      var planes = material.clippingPlanes,
        clipIntersection = material.clipIntersection,
        clipShadows = material.clipShadows
      var 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 {
        var nGlobal = renderingShadows ? 0 : numGlobalPlanes,
          lGlobal = nGlobal * 4
        var dstArray = materialProperties.clippingState || null
        uniform.value = dstArray // ensure unique state

        dstArray = projectPlanes(planes, camera, lGlobal, useCache)

        for (var 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) {
      var nPlanes = planes !== null ? planes.length : 0
      var dstArray = null

      if (nPlanes !== 0) {
        dstArray = uniform.value

        if (skipTransform !== true || dstArray === null) {
          var flatSize = dstOffset + nPlanes * 4,
            viewMatrix = camera.matrixWorldInverse
          viewNormalMatrix.getNormalMatrix(viewMatrix)

          if (dstArray === null || dstArray.length < flatSize) {
            dstArray = new Float32Array(flatSize)
          }

          for (var 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 WebGLCubeMaps(renderer) {
    var cubemaps = new WeakMap()

    function mapTextureMapping(texture, mapping) {
      if (mapping === EquirectangularReflectionMapping) {
        texture.mapping = CubeReflectionMapping
      } else if (mapping === EquirectangularRefractionMapping) {
        texture.mapping = CubeRefractionMapping
      }

      return texture
    }

    function get(texture) {
      if (texture && texture.isTexture) {
        var mapping = texture.mapping

        if (mapping === EquirectangularReflectionMapping || mapping === EquirectangularRefractionMapping) {
          if (cubemaps.has(texture)) {
            var cubemap = cubemaps.get(texture).texture
            return mapTextureMapping(cubemap, texture.mapping)
          } else {
            var image = texture.image

            if (image && image.height > 0) {
              var currentRenderList = renderer.getRenderList()
              var currentRenderTarget = renderer.getRenderTarget()
              var renderTarget = new WebGLCubeRenderTarget(image.height / 2)
              renderTarget.fromEquirectangularTexture(renderer, texture)
              cubemaps.set(texture, renderTarget)
              renderer.setRenderTarget(currentRenderTarget)
              renderer.setRenderList(currentRenderList)
              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) {
      var texture = event.target
      texture.removeEventListener('dispose', onTextureDispose)
      var cubemap = cubemaps.get(texture)

      if (cubemap !== undefined) {
        cubemaps.delete(texture)
        cubemap.dispose()
      }
    }

    function dispose() {
      cubemaps = new WeakMap()
    }

    return {
      get: get,
      dispose: dispose
    }
  }

  function WebGLExtensions(gl) {
    var extensions = {}
    return {
      has: function has(name) {
        if (extensions[name] !== undefined) {
          return extensions[name] !== null
        }

        var 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 !== null
      },
      get: function get(name) {
        if (!this.has(name)) {
          console.warn('THREE.WebGLRenderer: ' + name + ' extension not supported.')
        }

        return extensions[name]
      }
    }
  }

  function WebGLGeometries(gl, attributes, info, bindingStates) {
    var geometries = new WeakMap()
    var wireframeAttributes = new WeakMap()

    function onGeometryDispose(event) {
      var geometry = event.target
      var buffergeometry = geometries.get(geometry)

      if (buffergeometry.index !== null) {
        attributes.remove(buffergeometry.index)
      }

      for (var name in buffergeometry.attributes) {
        attributes.remove(buffergeometry.attributes[name])
      }

      geometry.removeEventListener('dispose', onGeometryDispose)
      geometries.delete(geometry)
      var attribute = wireframeAttributes.get(buffergeometry)

      if (attribute) {
        attributes.remove(attribute)
        wireframeAttributes.delete(buffergeometry)
      }

      bindingStates.releaseStatesOfGeometry(buffergeometry)

      if (geometry.isInstancedBufferGeometry === true) {
        delete geometry._maxInstanceCount
      } //

      info.memory.geometries--
    }

    function get(object, geometry) {
      var buffergeometry = geometries.get(geometry)
      if (buffergeometry) return buffergeometry
      geometry.addEventListener('dispose', onGeometryDispose)

      if (geometry.isBufferGeometry) {
        buffergeometry = geometry
      } else if (geometry.isGeometry) {
        if (geometry._bufferGeometry === undefined) {
          geometry._bufferGeometry = new BufferGeometry().setFromObject(object)
        }

        buffergeometry = geometry._bufferGeometry
      }

      geometries.set(geometry, buffergeometry)
      info.memory.geometries++
      return buffergeometry
    }

    function update(geometry) {
      var geometryAttributes = geometry.attributes // Updating index buffer in VAO now. See WebGLBindingStates.

      for (var name in geometryAttributes) {
        attributes.update(geometryAttributes[name], 34962)
      } // morph targets

      var morphAttributes = geometry.morphAttributes

      for (var _name in morphAttributes) {
        var array = morphAttributes[_name]

        for (var i = 0, l = array.length; i < l; i++) {
          attributes.update(array[i], 34962)
        }
      }
    }

    function updateWireframeAttribute(geometry) {
      var indices = []
      var geometryIndex = geometry.index
      var geometryPosition = geometry.attributes.position
      var version = 0

      if (geometryIndex !== null) {
        var array = geometryIndex.array
        version = geometryIndex.version

        for (var i = 0, l = array.length; i < l; i += 3) {
          var a = array[i + 0]
          var b = array[i + 1]
          var c = array[i + 2]
          indices.push(a, b, b, c, c, a)
        }
      } else {
        var _array = geometryPosition.array
        version = geometryPosition.version

        for (var _i = 0, _l = _array.length / 3 - 1; _i < _l; _i += 3) {
          var _a = _i + 0

          var _b = _i + 1

          var _c = _i + 2

          indices.push(_a, _b, _b, _c, _c, _a)
        }
      }

      var attribute = new (arrayMax(indices) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute)(indices, 1)
      attribute.version = version // Updating index buffer in VAO now. See WebGLBindingStates
      //

      var previousAttribute = wireframeAttributes.get(geometry)
      if (previousAttribute) attributes.remove(previousAttribute) //

      wireframeAttributes.set(geometry, attribute)
    }

    function getWireframeAttribute(geometry) {
      var currentAttribute = wireframeAttributes.get(geometry)

      if (currentAttribute) {
        var 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 WebGLIndexedBufferRenderer(gl, extensions, info, capabilities) {
    var isWebGL2 = capabilities.isWebGL2
    var mode

    function setMode(value) {
      mode = value
    }

    var 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
      var extension, methodName

      if (isWebGL2) {
        extension = gl
        methodName = 'drawElementsInstanced'
      } else {
        extension = extensions.get('ANGLE_instanced_arrays')
        methodName = 'drawElementsInstancedANGLE'

        if (extension === null) {
          console.error('THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.')
          return
        }
      }

      extension[methodName](mode, count, type, start * bytesPerElement, primcount)
      info.update(count, mode, primcount)
    } //

    this.setMode = setMode
    this.setIndex = setIndex
    this.render = render
    this.renderInstances = renderInstances
  }

  function WebGLInfo(gl) {
    var memory = {
      geometries: 0,
      textures: 0
    }
    var render = {
      frame: 0,
      calls: 0,
      triangles: 0,
      points: 0,
      lines: 0
    }

    function update(count, mode, instanceCount) {
      render.calls++

      switch (mode) {
        case 4:
          render.triangles += instanceCount * (count / 3)
          break

        case 1:
          render.lines += instanceCount * (count / 2)
          break

        case 3:
          render.lines += instanceCount * (count - 1)
          break

        case 2:
          render.lines += instanceCount * count
          break

        case 0:
          render.points += instanceCount * count
          break

        default:
          console.error('THREE.WebGLInfo: Unknown draw mode:', mode)
          break
      }
    }

    function reset() {
      render.frame++
      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 numericalSort(a, b) {
    return a[0] - b[0]
  }

  function absNumericalSort(a, b) {
    return Math.abs(b[1]) - Math.abs(a[1])
  }

  function WebGLMorphtargets(gl) {
    var influencesList = {}
    var morphInfluences = new Float32Array(8)
    var workInfluences = []

    for (var i = 0; i < 8; i++) {
      workInfluences[i] = [i, 0]
    }

    function update(object, geometry, material, program) {
      var objectInfluences = object.morphTargetInfluences // When object doesn't have morph target influences defined, we treat it as a 0-length array
      // This is important to make sure we set up morphTargetBaseInfluence / morphTargetInfluences

      var length = objectInfluences === undefined ? 0 : objectInfluences.length
      var influences = influencesList[geometry.id]

      if (influences === undefined) {
        // initialise list
        influences = []

        for (var _i = 0; _i < length; _i++) {
          influences[_i] = [_i, 0]
        }

        influencesList[geometry.id] = influences
      } // Collect influences

      for (var _i2 = 0; _i2 < length; _i2++) {
        var influence = influences[_i2]
        influence[0] = _i2
        influence[1] = objectInfluences[_i2]
      }

      influences.sort(absNumericalSort)

      for (var _i3 = 0; _i3 < 8; _i3++) {
        if (_i3 < length && influences[_i3][1]) {
          workInfluences[_i3][0] = influences[_i3][0]
          workInfluences[_i3][1] = influences[_i3][1]
        } else {
          workInfluences[_i3][0] = Number.MAX_SAFE_INTEGER
          workInfluences[_i3][1] = 0
        }
      }

      workInfluences.sort(numericalSort)
      var morphTargets = material.morphTargets && geometry.morphAttributes.position
      var morphNormals = material.morphNormals && geometry.morphAttributes.normal
      var morphInfluencesSum = 0

      for (var _i4 = 0; _i4 < 8; _i4++) {
        var _influence = workInfluences[_i4]
        var index = _influence[0]
        var value = _influence[1]

        if (index !== Number.MAX_SAFE_INTEGER && value) {
          if (morphTargets && geometry.getAttribute('morphTarget' + _i4) !== morphTargets[index]) {
            geometry.setAttribute('morphTarget' + _i4, morphTargets[index])
          }

          if (morphNormals && geometry.getAttribute('morphNormal' + _i4) !== morphNormals[index]) {
            geometry.setAttribute('morphNormal' + _i4, morphNormals[index])
          }

          morphInfluences[_i4] = value
          morphInfluencesSum += value
        } else {
          if (morphTargets && geometry.hasAttribute('morphTarget' + _i4) === true) {
            geometry.deleteAttribute('morphTarget' + _i4)
          }

          if (morphNormals && geometry.hasAttribute('morphNormal' + _i4) === true) {
            geometry.deleteAttribute('morphNormal' + _i4)
          }

          morphInfluences[_i4] = 0
        }
      } // GLSL shader uses formula baseinfluence * base + sum(target * influence)
      // This allows us to switch between absolute morphs and relative morphs without changing shader code
      // When baseinfluence = 1 - sum(influence), the above is equivalent to sum((target - base) * influence)

      var morphBaseInfluence = geometry.morphTargetsRelative ? 1 : 1 - morphInfluencesSum
      program.getUniforms().setValue(gl, 'morphTargetBaseInfluence', morphBaseInfluence)
      program.getUniforms().setValue(gl, 'morphTargetInfluences', morphInfluences)
    }

    return {
      update: update
    }
  }

  function WebGLObjects(gl, geometries, attributes, info) {
    var updateMap = new WeakMap()

    function update(object) {
      var frame = info.render.frame
      var geometry = object.geometry
      var buffergeometry = geometries.get(object, geometry) // Update once per frame

      if (updateMap.get(buffergeometry) !== frame) {
        if (geometry.isGeometry) {
          buffergeometry.updateFromObject(object)
        }

        geometries.update(buffergeometry)
        updateMap.set(buffergeometry, frame)
      }

      if (object.isInstancedMesh) {
        if (object.hasEventListener('dispose', onInstancedMeshDispose) === false) {
          object.addEventListener('dispose', onInstancedMeshDispose)
        }

        attributes.update(object.instanceMatrix, 34962)

        if (object.instanceColor !== null) {
          attributes.update(object.instanceColor, 34962)
        }
      }

      return buffergeometry
    }

    function dispose() {
      updateMap = new WeakMap()
    }

    function onInstancedMeshDispose(event) {
      var instancedMesh = event.target
      instancedMesh.removeEventListener('dispose', onInstancedMeshDispose)
      attributes.remove(instancedMesh.instanceMatrix)
      if (instancedMesh.instanceColor !== null) attributes.remove(instancedMesh.instanceColor)
    }

    return {
      update: update,
      dispose: dispose
    }
  }

  function DataTexture2DArray(data, width, height, depth) {
    if (data === void 0) {
      data = null
    }

    if (width === void 0) {
      width = 1
    }

    if (height === void 0) {
      height = 1
    }

    if (depth === void 0) {
      depth = 1
    }

    Texture.call(this, null)
    this.image = {
      data: data,
      width: width,
      height: height,
      depth: depth
    }
    this.magFilter = NearestFilter
    this.minFilter = NearestFilter
    this.wrapR = ClampToEdgeWrapping
    this.generateMipmaps = false
    this.flipY = false
    this.needsUpdate = true
  }

  DataTexture2DArray.prototype = Object.create(Texture.prototype)
  DataTexture2DArray.prototype.constructor = DataTexture2DArray
  DataTexture2DArray.prototype.isDataTexture2DArray = true

  function DataTexture3D(data, width, height, depth) {
    if (data === void 0) {
      data = null
    }

    if (width === void 0) {
      width = 1
    }

    if (height === void 0) {
      height = 1
    }

    if (depth === void 0) {
      depth = 1
    }

    // We're going to add .setXXX() methods for setting properties later.
    // Users can still set in DataTexture3D directly.
    //
    //	const texture = new THREE.DataTexture3D( data, width, height, depth );
    // 	texture.anisotropy = 16;
    //
    // See #14839
    Texture.call(this, null)
    this.image = {
      data: data,
      width: width,
      height: height,
      depth: depth
    }
    this.magFilter = NearestFilter
    this.minFilter = NearestFilter
    this.wrapR = ClampToEdgeWrapping
    this.generateMipmaps = false
    this.flipY = false
    this.needsUpdate = true
  }

  DataTexture3D.prototype = Object.create(Texture.prototype)
  DataTexture3D.prototype.constructor = DataTexture3D
  DataTexture3D.prototype.isDataTexture3D = true

  /**
   * 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
   *
   */
  var emptyTexture = new Texture()
  var emptyTexture2dArray = new DataTexture2DArray()
  var emptyTexture3d = new DataTexture3D()
  var emptyCubeTexture = new CubeTexture() // --- Utilities ---
  // Array Caches (provide typed arrays for temporary by size)

  var arrayCacheF32 = []
  var arrayCacheI32 = [] // Float32Array caches used for uploading Matrix uniforms

  var mat4array = new Float32Array(16)
  var mat3array = new Float32Array(9)
  var mat2array = new Float32Array(4) // Flattening for arrays of vectors and matrices

  function flatten(array, nBlocks, blockSize) {
    var firstElem = array[0]
    if (firstElem <= 0 || firstElem > 0) return array // unoptimized: ! isNaN( firstElem )
    // see http://jacksondunstan.com/articles/983

    var n = nBlocks * blockSize
    var r = arrayCacheF32[n]

    if (r === undefined) {
      r = new Float32Array(n)
      arrayCacheF32[n] = r
    }

    if (nBlocks !== 0) {
      firstElem.toArray(r, 0)

      for (var i = 1, offset = 0; i !== nBlocks; ++i) {
        offset += blockSize
        array[i].toArray(r, offset)
      }
    }

    return r
  }

  function arraysEqual(a, b) {
    if (a.length !== b.length) return false

    for (var i = 0, l = a.length; i < l; i++) {
      if (a[i] !== b[i]) return false
    }

    return true
  }

  function copyArray(a, b) {
    for (var i = 0, l = b.length; i < l; i++) {
      a[i] = b[i]
    }
  } // Texture unit allocation

  function allocTexUnits(textures, n) {
    var r = arrayCacheI32[n]

    if (r === undefined) {
      r = new Int32Array(n)
      arrayCacheI32[n] = r
    }

    for (var 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 setValueV1f(gl, v) {
    var 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 setValueV2f(gl, v) {
    var 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 (arraysEqual(cache, v)) return
      gl.uniform2fv(this.addr, v)
      copyArray(cache, v)
    }
  }

  function setValueV3f(gl, v) {
    var 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 (arraysEqual(cache, v)) return
      gl.uniform3fv(this.addr, v)
      copyArray(cache, v)
    }
  }

  function setValueV4f(gl, v) {
    var 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 (arraysEqual(cache, v)) return
      gl.uniform4fv(this.addr, v)
      copyArray(cache, v)
    }
  } // Single matrix (from flat array or MatrixN)

  function setValueM2(gl, v) {
    var cache = this.cache
    var elements = v.elements

    if (elements === undefined) {
      if (arraysEqual(cache, v)) return
      gl.uniformMatrix2fv(this.addr, false, v)
      copyArray(cache, v)
    } else {
      if (arraysEqual(cache, elements)) return
      mat2array.set(elements)
      gl.uniformMatrix2fv(this.addr, false, mat2array)
      copyArray(cache, elements)
    }
  }

  function setValueM3(gl, v) {
    var cache = this.cache
    var elements = v.elements

    if (elements === undefined) {
      if (arraysEqual(cache, v)) return
      gl.uniformMatrix3fv(this.addr, false, v)
      copyArray(cache, v)
    } else {
      if (arraysEqual(cache, elements)) return
      mat3array.set(elements)
      gl.uniformMatrix3fv(this.addr, false, mat3array)
      copyArray(cache, elements)
    }
  }

  function setValueM4(gl, v) {
    var cache = this.cache
    var elements = v.elements

    if (elements === undefined) {
      if (arraysEqual(cache, v)) return
      gl.uniformMatrix4fv(this.addr, false, v)
      copyArray(cache, v)
    } else {
      if (arraysEqual(cache, elements)) return
      mat4array.set(elements)
      gl.uniformMatrix4fv(this.addr, false, mat4array)
      copyArray(cache, elements)
    }
  } // Single texture (2D / Cube)

  function setValueT1(gl, v, textures) {
    var cache = this.cache
    var unit = textures.allocateTextureUnit()

    if (cache[0] !== unit) {
      gl.uniform1i(this.addr, unit)
      cache[0] = unit
    }

    textures.safeSetTexture2D(v || emptyTexture, unit)
  }

  function setValueT2DArray1(gl, v, textures) {
    var cache = this.cache
    var unit = textures.allocateTextureUnit()

    if (cache[0] !== unit) {
      gl.uniform1i(this.addr, unit)
      cache[0] = unit
    }

    textures.setTexture2DArray(v || emptyTexture2dArray, unit)
  }

  function setValueT3D1(gl, v, textures) {
    var cache = this.cache
    var unit = textures.allocateTextureUnit()

    if (cache[0] !== unit) {
      gl.uniform1i(this.addr, unit)
      cache[0] = unit
    }

    textures.setTexture3D(v || emptyTexture3d, unit)
  }

  function setValueT6(gl, v, textures) {
    var cache = this.cache
    var unit = textures.allocateTextureUnit()

    if (cache[0] !== unit) {
      gl.uniform1i(this.addr, unit)
      cache[0] = unit
    }

    textures.safeSetTextureCube(v || emptyCubeTexture, unit)
  } // Integer / Boolean vectors or arrays thereof (always flat arrays)

  function setValueV1i(gl, v) {
    var cache = this.cache
    if (cache[0] === v) return
    gl.uniform1i(this.addr, v)
    cache[0] = v
  }

  function setValueV2i(gl, v) {
    var cache = this.cache
    if (arraysEqual(cache, v)) return
    gl.uniform2iv(this.addr, v)
    copyArray(cache, v)
  }

  function setValueV3i(gl, v) {
    var cache = this.cache
    if (arraysEqual(cache, v)) return
    gl.uniform3iv(this.addr, v)
    copyArray(cache, v)
  }

  function setValueV4i(gl, v) {
    var cache = this.cache
    if (arraysEqual(cache, v)) return
    gl.uniform4iv(this.addr, v)
    copyArray(cache, v)
  } // uint

  function setValueV1ui(gl, v) {
    var cache = this.cache
    if (cache[0] === v) return
    gl.uniform1ui(this.addr, v)
    cache[0] = v
  } // Helper to pick the right setter for the singular case

  function getSingularSetter(type) {
    switch (type) {
      case 0x1406:
        return setValueV1f
      // FLOAT

      case 0x8b50:
        return setValueV2f
      // _VEC2

      case 0x8b51:
        return setValueV3f
      // _VEC3

      case 0x8b52:
        return setValueV4f
      // _VEC4

      case 0x8b5a:
        return setValueM2
      // _MAT2

      case 0x8b5b:
        return setValueM3
      // _MAT3

      case 0x8b5c:
        return setValueM4
      // _MAT4

      case 0x1404:
      case 0x8b56:
        return setValueV1i
      // INT, BOOL

      case 0x8b53:
      case 0x8b57:
        return setValueV2i
      // _VEC2

      case 0x8b54:
      case 0x8b58:
        return setValueV3i
      // _VEC3

      case 0x8b55:
      case 0x8b59:
        return setValueV4i
      // _VEC4

      case 0x1405:
        return setValueV1ui
      // UINT

      case 0x8b5e: // SAMPLER_2D

      case 0x8d66: // SAMPLER_EXTERNAL_OES

      case 0x8dca: // INT_SAMPLER_2D

      case 0x8dd2: // UNSIGNED_INT_SAMPLER_2D

      case 0x8b62:
        // SAMPLER_2D_SHADOW
        return setValueT1

      case 0x8b5f: // SAMPLER_3D

      case 0x8dcb: // INT_SAMPLER_3D

      case 0x8dd3:
        // UNSIGNED_INT_SAMPLER_3D
        return setValueT3D1

      case 0x8b60: // SAMPLER_CUBE

      case 0x8dcc: // INT_SAMPLER_CUBE

      case 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE

      case 0x8dc5:
        // SAMPLER_CUBE_SHADOW
        return setValueT6

      case 0x8dc1: // SAMPLER_2D_ARRAY

      case 0x8dcf: // INT_SAMPLER_2D_ARRAY

      case 0x8dd7: // UNSIGNED_INT_SAMPLER_2D_ARRAY

      case 0x8dc4:
        // SAMPLER_2D_ARRAY_SHADOW
        return setValueT2DArray1
    }
  } // Array of scalars

  function setValueV1fArray(gl, v) {
    gl.uniform1fv(this.addr, v)
  } // Integer / Boolean vectors or arrays thereof (always flat arrays)

  function setValueV1iArray(gl, v) {
    gl.uniform1iv(this.addr, v)
  }

  function setValueV2iArray(gl, v) {
    gl.uniform2iv(this.addr, v)
  }

  function setValueV3iArray(gl, v) {
    gl.uniform3iv(this.addr, v)
  }

  function setValueV4iArray(gl, v) {
    gl.uniform4iv(this.addr, v)
  } // Array of vectors (flat or from THREE classes)

  function setValueV2fArray(gl, v) {
    var data = flatten(v, this.size, 2)
    gl.uniform2fv(this.addr, data)
  }

  function setValueV3fArray(gl, v) {
    var data = flatten(v, this.size, 3)
    gl.uniform3fv(this.addr, data)
  }

  function setValueV4fArray(gl, v) {
    var data = flatten(v, this.size, 4)
    gl.uniform4fv(this.addr, data)
  } // Array of matrices (flat or from THREE clases)

  function setValueM2Array(gl, v) {
    var data = flatten(v, this.size, 4)
    gl.uniformMatrix2fv(this.addr, false, data)
  }

  function setValueM3Array(gl, v) {
    var data = flatten(v, this.size, 9)
    gl.uniformMatrix3fv(this.addr, false, data)
  }

  function setValueM4Array(gl, v) {
    var data = flatten(v, this.size, 16)
    gl.uniformMatrix4fv(this.addr, false, data)
  } // Array of textures (2D / Cube)

  function setValueT1Array(gl, v, textures) {
    var n = v.length
    var units = allocTexUnits(textures, n)
    gl.uniform1iv(this.addr, units)

    for (var i = 0; i !== n; ++i) {
      textures.safeSetTexture2D(v[i] || emptyTexture, units[i])
    }
  }

  function setValueT6Array(gl, v, textures) {
    var n = v.length
    var units = allocTexUnits(textures, n)
    gl.uniform1iv(this.addr, units)

    for (var i = 0; i !== n; ++i) {
      textures.safeSetTextureCube(v[i] || emptyCubeTexture, units[i])
    }
  } // Helper to pick the right setter for a pure (bottom-level) array

  function getPureArraySetter(type) {
    switch (type) {
      case 0x1406:
        return setValueV1fArray
      // FLOAT

      case 0x8b50:
        return setValueV2fArray
      // _VEC2

      case 0x8b51:
        return setValueV3fArray
      // _VEC3

      case 0x8b52:
        return setValueV4fArray
      // _VEC4

      case 0x8b5a:
        return setValueM2Array
      // _MAT2

      case 0x8b5b:
        return setValueM3Array
      // _MAT3

      case 0x8b5c:
        return setValueM4Array
      // _MAT4

      case 0x1404:
      case 0x8b56:
        return setValueV1iArray
      // INT, BOOL

      case 0x8b53:
      case 0x8b57:
        return setValueV2iArray
      // _VEC2

      case 0x8b54:
      case 0x8b58:
        return setValueV3iArray
      // _VEC3

      case 0x8b55:
      case 0x8b59:
        return setValueV4iArray
      // _VEC4

      case 0x8b5e: // SAMPLER_2D

      case 0x8d66: // SAMPLER_EXTERNAL_OES

      case 0x8dca: // INT_SAMPLER_2D

      case 0x8dd2: // UNSIGNED_INT_SAMPLER_2D

      case 0x8b62:
        // SAMPLER_2D_SHADOW
        return setValueT1Array

      case 0x8b60: // SAMPLER_CUBE

      case 0x8dcc: // INT_SAMPLER_CUBE

      case 0x8dd4: // UNSIGNED_INT_SAMPLER_CUBE

      case 0x8dc5:
        // SAMPLER_CUBE_SHADOW
        return setValueT6Array
    }
  } // --- Uniform Classes ---

  function SingleUniform(id, activeInfo, addr) {
    this.id = id
    this.addr = addr
    this.cache = []
    this.setValue = getSingularSetter(activeInfo.type) // this.path = activeInfo.name; // DEBUG
  }

  function PureArrayUniform(id, activeInfo, addr) {
    this.id = id
    this.addr = addr
    this.cache = []
    this.size = activeInfo.size
    this.setValue = getPureArraySetter(activeInfo.type) // this.path = activeInfo.name; // DEBUG
  }

  PureArrayUniform.prototype.updateCache = function (data) {
    var cache = this.cache

    if (data instanceof Float32Array && cache.length !== data.length) {
      this.cache = new Float32Array(data.length)
    }

    copyArray(cache, data)
  }

  function StructuredUniform(id) {
    this.id = id
    this.seq = []
    this.map = {}
  }

  StructuredUniform.prototype.setValue = function (gl, value, textures) {
    var seq = this.seq

    for (var i = 0, n = seq.length; i !== n; ++i) {
      var u = seq[i]
      u.setValue(gl, value[u.id], textures)
    }
  } // --- Top-level ---
  // Parser - builds up the property tree from the path strings

  var RePathPart = /([\w\d_]+)(\])?(\[|\.)?/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 addUniform(container, uniformObject) {
    container.seq.push(uniformObject)
    container.map[uniformObject.id] = uniformObject
  }

  function parseUniform(activeInfo, addr, container) {
    var path = activeInfo.name,
      pathLength = path.length // reset RegExp object, because of the early exit of a previous run

    RePathPart.lastIndex = 0

    while (true) {
      var match = RePathPart.exec(path),
        matchEnd = RePathPart.lastIndex
      var id = match[1]
      var 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
        addUniform(container, subscript === undefined ? new SingleUniform(id, activeInfo, addr) : new PureArrayUniform(id, activeInfo, addr))
        break
      } else {
        // step into inner node / create it in case it doesn't exist
        var map = container.map
        var next = map[id]

        if (next === undefined) {
          next = new StructuredUniform(id)
          addUniform(container, next)
        }

        container = next
      }
    }
  } // Root Container

  function WebGLUniforms(gl, program) {
    this.seq = []
    this.map = {}
    var n = gl.getProgramParameter(program, 35718)

    for (var i = 0; i < n; ++i) {
      var info = gl.getActiveUniform(program, i),
        addr = gl.getUniformLocation(program, info.name)
      parseUniform(info, addr, this)
    }
  }

  WebGLUniforms.prototype.setValue = function (gl, name, value, textures) {
    var u = this.map[name]
    if (u !== undefined) u.setValue(gl, value, textures)
  }

  WebGLUniforms.prototype.setOptional = function (gl, object, name) {
    var v = object[name]
    if (v !== undefined) this.setValue(gl, name, v)
  } // Static interface

  WebGLUniforms.upload = function (gl, seq, values, textures) {
    for (var i = 0, n = seq.length; i !== n; ++i) {
      var u = seq[i],
        v = values[u.id]

      if (v.needsUpdate !== false) {
        // note: always updating when .needsUpdate is undefined
        u.setValue(gl, v.value, textures)
      }
    }
  }

  WebGLUniforms.seqWithValue = function (seq, values) {
    var r = []

    for (var i = 0, n = seq.length; i !== n; ++i) {
      var u = seq[i]
      if (u.id in values) r.push(u)
    }

    return r
  }

  function WebGLShader(gl, type, string) {
    var shader = gl.createShader(type)
    gl.shaderSource(shader, string)
    gl.compileShader(shader)
    return shader
  }

  var programIdCount = 0

  function addLineNumbers(string) {
    var lines = string.split('\n')

    for (var i = 0; i < lines.length; i++) {
      lines[i] = i + 1 + ': ' + lines[i]
    }

    return lines.join('\n')
  }

  function getEncodingComponents(encoding) {
    switch (encoding) {
      case LinearEncoding:
        return ['Linear', '( value )']

      case sRGBEncoding:
        return ['sRGB', '( value )']

      case RGBEEncoding:
        return ['RGBE', '( value )']

      case RGBM7Encoding:
        return ['RGBM', '( value, 7.0 )']

      case RGBM16Encoding:
        return ['RGBM', '( value, 16.0 )']

      case RGBDEncoding:
        return ['RGBD', '( value, 256.0 )']

      case GammaEncoding:
        return ['Gamma', '( value, float( GAMMA_FACTOR ) )']

      case LogLuvEncoding:
        return ['LogLuv', '( value )']

      default:
        console.warn('THREE.WebGLProgram: Unsupported encoding:', encoding)
        return ['Linear', '( value )']
    }
  }

  function getShaderErrors(gl, shader, type) {
    var status = gl.getShaderParameter(shader, 35713)
    var log = gl.getShaderInfoLog(shader).trim()
    if (status && log === '') return '' // --enable-privileged-webgl-extension
    // console.log( '**' + type + '**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );

    var source = gl.getShaderSource(shader)
    return 'THREE.WebGLShader: gl.getShaderInfoLog() ' + type + '\n' + log + addLineNumbers(source)
  }

  function getTexelDecodingFunction(functionName, encoding) {
    var components = getEncodingComponents(encoding)
    return 'vec4 ' + functionName + '( vec4 value ) { return ' + components[0] + 'ToLinear' + components[1] + '; }'
  }

  function getTexelEncodingFunction(functionName, encoding) {
    var components = getEncodingComponents(encoding)
    return 'vec4 ' + functionName + '( vec4 value ) { return LinearTo' + components[0] + components[1] + '; }'
  }

  function getToneMappingFunction(functionName, toneMapping) {
    var toneMappingName

    switch (toneMapping) {
      case LinearToneMapping:
        toneMappingName = 'Linear'
        break

      case ReinhardToneMapping:
        toneMappingName = 'Reinhard'
        break

      case CineonToneMapping:
        toneMappingName = 'OptimizedCineon'
        break

      case ACESFilmicToneMapping:
        toneMappingName = 'ACESFilmic'
        break

      case CustomToneMapping:
        toneMappingName = 'Custom'
        break

      default:
        console.warn('THREE.WebGLProgram: Unsupported toneMapping:', toneMapping)
        toneMappingName = 'Linear'
    }

    return 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }'
  }

  function generateExtensions(parameters) {
    var chunks = [
      parameters.extensionDerivatives ||
      parameters.envMapCubeUV ||
      parameters.bumpMap ||
      parameters.tangentSpaceNormalMap ||
      parameters.clearcoatNormalMap ||
      parameters.flatShading ||
      parameters.shaderID === 'physical'
        ? '#extension GL_OES_standard_derivatives : enable'
        : '',
      (parameters.extensionFragDepth || parameters.logarithmicDepthBuffer) && parameters.rendererExtensionFragDepth ? '#extension GL_EXT_frag_depth : enable' : '',
      parameters.extensionDrawBuffers && parameters.rendererExtensionDrawBuffers ? '#extension GL_EXT_draw_buffers : require' : '',
      (parameters.extensionShaderTextureLOD || parameters.envMap) && parameters.rendererExtensionShaderTextureLod ? '#extension GL_EXT_shader_texture_lod : enable' : ''
    ]
    return chunks.filter(filterEmptyLine).join('\n')
  }

  function generateDefines(defines) {
    var chunks = []

    for (var name in defines) {
      var value = defines[name]
      if (value === false) continue
      chunks.push('#define ' + name + ' ' + value)
    }

    return chunks.join('\n')
  }

  function fetchAttributeLocations(gl, program) {
    var attributes = {}
    var n = gl.getProgramParameter(program, 35721)

    for (var i = 0; i < n; i++) {
      var info = gl.getActiveAttrib(program, i)
      var name = info.name // console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );

      attributes[name] = gl.getAttribLocation(program, name)
    }

    return attributes
  }

  function filterEmptyLine(string) {
    return string !== ''
  }

  function replaceLightNums(string, parameters) {
    return string
      .replace(/NUM_DIR_LIGHTS/g, parameters.numDirLights)
      .replace(/NUM_SPOT_LIGHTS/g, parameters.numSpotLights)
      .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/g, parameters.numSpotLightShadows)
      .replace(/NUM_POINT_LIGHT_SHADOWS/g, parameters.numPointLightShadows)
  }

  function replaceClippingPlaneNums(string, parameters) {
    return string
      .replace(/NUM_CLIPPING_PLANES/g, parameters.numClippingPlanes)
      .replace(/UNION_CLIPPING_PLANES/g, parameters.numClippingPlanes - parameters.numClipIntersection)
  } // Resolve Includes

  var includePattern = /^[ \t]*#include +<([\w\d./]+)>/gm

  function resolveIncludes(string) {
    return string.replace(includePattern, includeReplacer)
  }

  function includeReplacer(match, include) {
    var string = ShaderChunk[include]

    if (string === undefined) {
      throw new Error('Can not resolve #include <' + include + '>')
    }

    return resolveIncludes(string)
  } // Unroll Loops

  var deprecatedUnrollLoopPattern = /#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g
  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 unrollLoops(string) {
    return string.replace(unrollLoopPattern, loopReplacer).replace(deprecatedUnrollLoopPattern, deprecatedLoopReplacer)
  }

  function deprecatedLoopReplacer(match, start, end, snippet) {
    console.warn('WebGLProgram: #pragma unroll_loop shader syntax is deprecated. Please use #pragma unroll_loop_start syntax instead.')
    return loopReplacer(match, start, end, snippet)
  }

  function loopReplacer(match, start, end, snippet) {
    var string = ''

    for (var i = parseInt(start); i < parseInt(end); i++) {
      string += snippet.replace(/\[\s*i\s*\]/g, '[ ' + i + ' ]').replace(/UNROLLED_LOOP_INDEX/g, i)
    }

    return string
  } //

  function generatePrecision(parameters) {
    var precisionstring = 'precision ' + parameters.precision + ' float;\nprecision ' + parameters.precision + ' int;'

    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 generateShadowMapTypeDefine(parameters) {
    var shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC'

    if (parameters.shadowMapType === PCFShadowMap) {
      shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF'
    } else if (parameters.shadowMapType === PCFSoftShadowMap) {
      shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT'
    } else if (parameters.shadowMapType === VSMShadowMap) {
      shadowMapTypeDefine = 'SHADOWMAP_TYPE_VSM'
    }

    return shadowMapTypeDefine
  }

  function generateEnvMapTypeDefine(parameters) {
    var envMapTypeDefine = 'ENVMAP_TYPE_CUBE'

    if (parameters.envMap) {
      switch (parameters.envMapMode) {
        case CubeReflectionMapping:
        case CubeRefractionMapping:
          envMapTypeDefine = 'ENVMAP_TYPE_CUBE'
          break

        case CubeUVReflectionMapping:
        case CubeUVRefractionMapping:
          envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV'
          break
      }
    }

    return envMapTypeDefine
  }

  function generateEnvMapModeDefine(parameters) {
    var envMapModeDefine = 'ENVMAP_MODE_REFLECTION'

    if (parameters.envMap) {
      switch (parameters.envMapMode) {
        case CubeRefractionMapping:
        case CubeUVRefractionMapping:
          envMapModeDefine = 'ENVMAP_MODE_REFRACTION'
          break
      }
    }

    return envMapModeDefine
  }

  function generateEnvMapBlendingDefine(parameters) {
    var envMapBlendingDefine = 'ENVMAP_BLENDING_NONE'

    if (parameters.envMap) {
      switch (parameters.combine) {
        case MultiplyOperation:
          envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'
          break

        case MixOperation:
          envMapBlendingDefine = 'ENVMAP_BLENDING_MIX'
          break

        case AddOperation:
          envMapBlendingDefine = 'ENVMAP_BLENDING_ADD'
          break
      }
    }

    return envMapBlendingDefine
  }

  function WebGLProgram(renderer, cacheKey, parameters, bindingStates) {
    var gl = renderer.getContext()
    var defines = parameters.defines
    var vertexShader = parameters.vertexShader
    var fragmentShader = parameters.fragmentShader
    var shadowMapTypeDefine = generateShadowMapTypeDefine(parameters)
    var envMapTypeDefine = generateEnvMapTypeDefine(parameters)
    var envMapModeDefine = generateEnvMapModeDefine(parameters)
    var envMapBlendingDefine = generateEnvMapBlendingDefine(parameters)
    var gammaFactorDefine = renderer.gammaFactor > 0 ? renderer.gammaFactor : 1.0
    var customExtensions = parameters.isWebGL2 ? '' : generateExtensions(parameters)
    var customDefines = generateDefines(defines)
    var program = gl.createProgram()
    var prefixVertex, prefixFragment
    var versionString = parameters.glslVersion ? '#version ' + parameters.glslVersion + '\n' : ''

    if (parameters.isRawShaderMaterial) {
      prefixVertex = [customDefines].filter(filterEmptyLine).join('\n')

      if (prefixVertex.length > 0) {
        prefixVertex += '\n'
      }

      prefixFragment = [customExtensions, customDefines].filter(filterEmptyLine).join('\n')

      if (prefixFragment.length > 0) {
        prefixFragment += '\n'
      }
    } else {
      prefixVertex = [
        generatePrecision(parameters),
        '#define SHADER_NAME ' + parameters.shaderName,
        customDefines,
        parameters.instancing ? '#define USE_INSTANCING' : '',
        parameters.instancingColor ? '#define USE_INSTANCING_COLOR' : '',
        parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',
        '#define GAMMA_FACTOR ' + gammaFactorDefine,
        '#define MAX_BONES ' + parameters.maxBones,
        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.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
        parameters.bumpMap ? '#define USE_BUMPMAP' : '',
        parameters.normalMap ? '#define USE_NORMALMAP' : '',
        parameters.normalMap && parameters.objectSpaceNormalMap ? '#define OBJECTSPACE_NORMALMAP' : '',
        parameters.normalMap && parameters.tangentSpaceNormalMap ? '#define TANGENTSPACE_NORMALMAP' : '',
        parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
        parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
        parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
        parameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '',
        parameters.specularMap ? '#define USE_SPECULARMAP' : '',
        parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
        parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
        parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
        parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
        parameters.vertexTangents ? '#define USE_TANGENT' : '',
        parameters.vertexColors ? '#define USE_COLOR' : '',
        parameters.vertexUvs ? '#define USE_UV' : '',
        parameters.uvsVertexOnly ? '#define UVS_VERTEX_ONLY' : '',
        parameters.flatShading ? '#define FLAT_SHADED' : '',
        parameters.skinning ? '#define USE_SKINNING' : '',
        parameters.useVertexTexture ? '#define BONE_TEXTURE' : '',
        parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
        parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',
        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.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
        parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ? '#define USE_LOGDEPTHBUF_EXT' : '',
        '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',
        'attribute vec3 position;',
        'attribute vec3 normal;',
        'attribute vec2 uv;',
        '#ifdef USE_TANGENT',
        '	attribute vec4 tangent;',
        '#endif',
        '#ifdef USE_COLOR',
        '	attribute vec3 color;',
        '#endif',
        '#ifdef USE_MORPHTARGETS',
        '	attribute vec3 morphTarget0;',
        '	attribute vec3 morphTarget1;',
        '	attribute vec3 morphTarget2;',
        '	attribute vec3 morphTarget3;',
        '	#ifdef USE_MORPHNORMALS',
        '		attribute vec3 morphNormal0;',
        '		attribute vec3 morphNormal1;',
        '		attribute vec3 morphNormal2;',
        '		attribute vec3 morphNormal3;',
        '	#else',
        '		attribute vec3 morphTarget4;',
        '		attribute vec3 morphTarget5;',
        '		attribute vec3 morphTarget6;',
        '		attribute vec3 morphTarget7;',
        '	#endif',
        '#endif',
        '#ifdef USE_SKINNING',
        '	attribute vec4 skinIndex;',
        '	attribute vec4 skinWeight;',
        '#endif',
        '\n'
      ]
        .filter(filterEmptyLine)
        .join('\n')
      prefixFragment = [
        customExtensions,
        generatePrecision(parameters),
        '#define SHADER_NAME ' + parameters.shaderName,
        customDefines,
        parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest + (parameters.alphaTest % 1 ? '' : '.0') : '', // add '.0' if integer
        '#define GAMMA_FACTOR ' + gammaFactorDefine,
        parameters.useFog && parameters.fog ? '#define USE_FOG' : '',
        parameters.useFog && parameters.fogExp2 ? '#define FOG_EXP2' : '',
        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 : '',
        parameters.lightMap ? '#define USE_LIGHTMAP' : '',
        parameters.aoMap ? '#define USE_AOMAP' : '',
        parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
        parameters.bumpMap ? '#define USE_BUMPMAP' : '',
        parameters.normalMap ? '#define USE_NORMALMAP' : '',
        parameters.normalMap && parameters.objectSpaceNormalMap ? '#define OBJECTSPACE_NORMALMAP' : '',
        parameters.normalMap && parameters.tangentSpaceNormalMap ? '#define TANGENTSPACE_NORMALMAP' : '',
        parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
        parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
        parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
        parameters.specularMap ? '#define USE_SPECULARMAP' : '',
        parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
        parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
        parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
        parameters.sheen ? '#define USE_SHEEN' : '',
        parameters.transmissionMap ? '#define USE_TRANSMISSIONMAP' : '',
        parameters.vertexTangents ? '#define USE_TANGENT' : '',
        parameters.vertexColors || parameters.instancingColor ? '#define USE_COLOR' : '',
        parameters.vertexUvs ? '#define USE_UV' : '',
        parameters.uvsVertexOnly ? '#define UVS_VERTEX_ONLY' : '',
        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.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '',
        parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
        parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ? '#define USE_LOGDEPTHBUF_EXT' : '',
        (parameters.extensionShaderTextureLOD || parameters.envMap) && parameters.rendererExtensionShaderTextureLod ? '#define TEXTURE_LOD_EXT' : '',
        'uniform mat4 viewMatrix;',
        'uniform vec3 cameraPosition;',
        'uniform bool isOrthographic;',
        parameters.toneMapping !== NoToneMapping ? '#define TONE_MAPPING' : '',
        parameters.toneMapping !== NoToneMapping ? ShaderChunk['tonemapping_pars_fragment'] : '', // this code is required here because it is used by the toneMapping() function defined below
        parameters.toneMapping !== NoToneMapping ? getToneMappingFunction('toneMapping', parameters.toneMapping) : '',
        parameters.dithering ? '#define DITHERING' : '',
        ShaderChunk['encodings_pars_fragment'], // this code is required here because it is used by the various encoding/decoding function defined below
        parameters.map ? getTexelDecodingFunction('mapTexelToLinear', parameters.mapEncoding) : '',
        parameters.matcap ? getTexelDecodingFunction('matcapTexelToLinear', parameters.matcapEncoding) : '',
        parameters.envMap ? getTexelDecodingFunction('envMapTexelToLinear', parameters.envMapEncoding) : '',
        parameters.emissiveMap ? getTexelDecodingFunction('emissiveMapTexelToLinear', parameters.emissiveMapEncoding) : '',
        parameters.lightMap ? getTexelDecodingFunction('lightMapTexelToLinear', parameters.lightMapEncoding) : '',
        getTexelEncodingFunction('linearToOutputTexel', parameters.outputEncoding),
        parameters.depthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',
        '\n'
      ]
        .filter(filterEmptyLine)
        .join('\n')
    }

    vertexShader = resolveIncludes(vertexShader)
    vertexShader = replaceLightNums(vertexShader, parameters)
    vertexShader = replaceClippingPlaneNums(vertexShader, parameters)
    fragmentShader = resolveIncludes(fragmentShader)
    fragmentShader = replaceLightNums(fragmentShader, parameters)
    fragmentShader = replaceClippingPlaneNums(fragmentShader, parameters)
    vertexShader = unrollLoops(vertexShader)
    fragmentShader = unrollLoops(fragmentShader)

    if (parameters.isWebGL2 && parameters.isRawShaderMaterial !== true) {
      // GLSL 3.0 conversion for built-in materials and ShaderMaterial
      versionString = '#version 300 es\n'
      prefixVertex = ['#define attribute in', '#define varying out', '#define texture2D texture'].join('\n') + '\n' + prefixVertex
      prefixFragment =
        [
          '#define varying in',
          parameters.glslVersion === GLSL3 ? '' : 'out highp vec4 pc_fragColor;',
          parameters.glslVersion === GLSL3 ? '' : '#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
    }

    var vertexGlsl = versionString + prefixVertex + vertexShader
    var fragmentGlsl = versionString + prefixFragment + fragmentShader // console.log( '*VERTEX*', vertexGlsl );
    // console.log( '*FRAGMENT*', fragmentGlsl );

    var glVertexShader = WebGLShader(gl, 35633, vertexGlsl)
    var glFragmentShader = WebGLShader(gl, 35632, 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) // check for link errors

    if (renderer.debug.checkShaderErrors) {
      var programLog = gl.getProgramInfoLog(program).trim()
      var vertexLog = gl.getShaderInfoLog(glVertexShader).trim()
      var fragmentLog = gl.getShaderInfoLog(glFragmentShader).trim()
      var runnable = true
      var haveDiagnostics = true

      if (gl.getProgramParameter(program, 35714) === false) {
        runnable = false
        var vertexErrors = getShaderErrors(gl, glVertexShader, 'vertex')
        var fragmentErrors = getShaderErrors(gl, glFragmentShader, 'fragment')
        console.error(
          'THREE.WebGLProgram: shader error: ',
          gl.getError(),
          '35715',
          gl.getProgramParameter(program, 35715),
          'gl.getProgramInfoLog',
          programLog,
          vertexErrors,
          fragmentErrors
        )
      } else if (programLog !== '') {
        console.warn('THREE.WebGLProgram: gl.getProgramInfoLog()', programLog)
      } else if (vertexLog === '' || fragmentLog === '') {
        haveDiagnostics = false
      }

      if (haveDiagnostics) {
        this.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) // set up caching for uniform locations

    var cachedUniforms

    this.getUniforms = function () {
      if (cachedUniforms === undefined) {
        cachedUniforms = new WebGLUniforms(gl, program)
      }

      return cachedUniforms
    } // set up caching for attribute locations

    var cachedAttributes

    this.getAttributes = function () {
      if (cachedAttributes === undefined) {
        cachedAttributes = fetchAttributeLocations(gl, program)
      }

      return cachedAttributes
    } // free resource

    this.destroy = function () {
      bindingStates.releaseStatesOfProgram(this)
      gl.deleteProgram(program)
      this.program = undefined
    } //

    this.name = parameters.shaderName
    this.id = programIdCount++
    this.cacheKey = cacheKey
    this.usedTimes = 1
    this.program = program
    this.vertexShader = glVertexShader
    this.fragmentShader = glFragmentShader
    return this
  }

  function WebGLPrograms(renderer, cubemaps, extensions, capabilities, bindingStates, clipping) {
    var programs = []
    var isWebGL2 = capabilities.isWebGL2
    var logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer
    var floatVertexTextures = capabilities.floatVertexTextures
    var maxVertexUniforms = capabilities.maxVertexUniforms
    var vertexTextures = capabilities.vertexTextures
    var precision = capabilities.precision
    var 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'
    }
    var parameterNames = [
      'precision',
      'isWebGL2',
      'supportsVertexTextures',
      'outputEncoding',
      'instancing',
      'instancingColor',
      'map',
      'mapEncoding',
      'matcap',
      'matcapEncoding',
      'envMap',
      'envMapMode',
      'envMapEncoding',
      'envMapCubeUV',
      'lightMap',
      'lightMapEncoding',
      'aoMap',
      'emissiveMap',
      'emissiveMapEncoding',
      'bumpMap',
      'normalMap',
      'objectSpaceNormalMap',
      'tangentSpaceNormalMap',
      'clearcoatMap',
      'clearcoatRoughnessMap',
      'clearcoatNormalMap',
      'displacementMap',
      'specularMap',
      'roughnessMap',
      'metalnessMap',
      'gradientMap',
      'alphaMap',
      'combine',
      'vertexColors',
      'vertexTangents',
      'vertexUvs',
      'uvsVertexOnly',
      'fog',
      'useFog',
      'fogExp2',
      'flatShading',
      'sizeAttenuation',
      'logarithmicDepthBuffer',
      'skinning',
      'maxBones',
      'useVertexTexture',
      'morphTargets',
      'morphNormals',
      'maxMorphTargets',
      'maxMorphNormals',
      'premultipliedAlpha',
      'numDirLights',
      'numPointLights',
      'numSpotLights',
      'numHemiLights',
      'numRectAreaLights',
      'numDirLightShadows',
      'numPointLightShadows',
      'numSpotLightShadows',
      'shadowMapEnabled',
      'shadowMapType',
      'toneMapping',
      'physicallyCorrectLights',
      'alphaTest',
      'doubleSided',
      'flipSided',
      'numClippingPlanes',
      'numClipIntersection',
      'depthPacking',
      'dithering',
      'sheen',
      'transmissionMap'
    ]

    function getMaxBones(object) {
      var skeleton = object.skeleton
      var bones = skeleton.bones

      if (floatVertexTextures) {
        return 1024
      } else {
        // default for when object is not specified
        // ( for example when prebuilding shader to be used with multiple objects )
        //
        //	- leave some extra space for other uniforms
        //	- limit here is ANGLE's 254 max uniform vectors
        //		(up to 54 should be safe)
        var nVertexUniforms = maxVertexUniforms
        var nVertexMatrices = Math.floor((nVertexUniforms - 20) / 4)
        var maxBones = Math.min(nVertexMatrices, bones.length)

        if (maxBones < bones.length) {
          console.warn('THREE.WebGLRenderer: Skeleton has ' + bones.length + ' bones. This GPU supports ' + maxBones + '.')
          return 0
        }

        return maxBones
      }
    }

    function getTextureEncodingFromMap(map) {
      var encoding

      if (map && map.isTexture) {
        encoding = map.encoding
      } else if (map && map.isWebGLRenderTarget) {
        console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead.")
        encoding = map.texture.encoding
      } else {
        encoding = LinearEncoding
      }

      return encoding
    }

    function getParameters(material, lights, shadows, scene, object) {
      var fog = scene.fog
      var environment = material.isMeshStandardMaterial ? scene.environment : null
      var envMap = cubemaps.get(material.envMap || environment)
      var shaderID = shaderIDs[material.type] // heuristics to create shader parameters according to lights in the scene
      // (not to blow over maxLights budget)

      var maxBones = object.isSkinnedMesh ? getMaxBones(object) : 0

      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.')
        }
      }

      var vertexShader, fragmentShader

      if (shaderID) {
        var shader = ShaderLib[shaderID]
        vertexShader = shader.vertexShader
        fragmentShader = shader.fragmentShader
      } else {
        vertexShader = material.vertexShader
        fragmentShader = material.fragmentShader
      }

      var currentRenderTarget = renderer.getRenderTarget()
      var parameters = {
        isWebGL2: isWebGL2,
        shaderID: shaderID,
        shaderName: material.type,
        vertexShader: vertexShader,
        fragmentShader: fragmentShader,
        defines: material.defines,
        isRawShaderMaterial: material.isRawShaderMaterial === true,
        glslVersion: material.glslVersion,
        precision: precision,
        instancing: object.isInstancedMesh === true,
        instancingColor: object.isInstancedMesh === true && object.instanceColor !== null,
        supportsVertexTextures: vertexTextures,
        outputEncoding: currentRenderTarget !== null ? getTextureEncodingFromMap(currentRenderTarget.texture) : renderer.outputEncoding,
        map: !!material.map,
        mapEncoding: getTextureEncodingFromMap(material.map),
        matcap: !!material.matcap,
        matcapEncoding: getTextureEncodingFromMap(material.matcap),
        envMap: !!envMap,
        envMapMode: envMap && envMap.mapping,
        envMapEncoding: getTextureEncodingFromMap(envMap),
        envMapCubeUV: !!envMap && (envMap.mapping === CubeUVReflectionMapping || envMap.mapping === CubeUVRefractionMapping),
        lightMap: !!material.lightMap,
        lightMapEncoding: getTextureEncodingFromMap(material.lightMap),
        aoMap: !!material.aoMap,
        emissiveMap: !!material.emissiveMap,
        emissiveMapEncoding: getTextureEncodingFromMap(material.emissiveMap),
        bumpMap: !!material.bumpMap,
        normalMap: !!material.normalMap,
        objectSpaceNormalMap: material.normalMapType === ObjectSpaceNormalMap,
        tangentSpaceNormalMap: material.normalMapType === TangentSpaceNormalMap,
        clearcoatMap: !!material.clearcoatMap,
        clearcoatRoughnessMap: !!material.clearcoatRoughnessMap,
        clearcoatNormalMap: !!material.clearcoatNormalMap,
        displacementMap: !!material.displacementMap,
        roughnessMap: !!material.roughnessMap,
        metalnessMap: !!material.metalnessMap,
        specularMap: !!material.specularMap,
        alphaMap: !!material.alphaMap,
        gradientMap: !!material.gradientMap,
        sheen: !!material.sheen,
        transmissionMap: !!material.transmissionMap,
        combine: material.combine,
        vertexTangents: material.normalMap && material.vertexTangents,
        vertexColors: material.vertexColors,
        vertexUvs:
          !!material.map ||
          !!material.bumpMap ||
          !!material.normalMap ||
          !!material.specularMap ||
          !!material.alphaMap ||
          !!material.emissiveMap ||
          !!material.roughnessMap ||
          !!material.metalnessMap ||
          !!material.clearcoatMap ||
          !!material.clearcoatRoughnessMap ||
          !!material.clearcoatNormalMap ||
          !!material.displacementMap ||
          !!material.transmissionMap,
        uvsVertexOnly:
          !(
            !!material.map ||
            !!material.bumpMap ||
            !!material.normalMap ||
            !!material.specularMap ||
            !!material.alphaMap ||
            !!material.emissiveMap ||
            !!material.roughnessMap ||
            !!material.metalnessMap ||
            !!material.clearcoatNormalMap ||
            !!material.transmissionMap
          ) && !!material.displacementMap,
        fog: !!fog,
        useFog: material.fog,
        fogExp2: fog && fog.isFogExp2,
        flatShading: material.flatShading,
        sizeAttenuation: material.sizeAttenuation,
        logarithmicDepthBuffer: logarithmicDepthBuffer,
        skinning: material.skinning && maxBones > 0,
        maxBones: maxBones,
        useVertexTexture: floatVertexTextures,
        morphTargets: material.morphTargets,
        morphNormals: material.morphNormals,
        maxMorphTargets: renderer.maxMorphTargets,
        maxMorphNormals: renderer.maxMorphNormals,
        numDirLights: lights.directional.length,
        numPointLights: lights.point.length,
        numSpotLights: lights.spot.length,
        numRectAreaLights: lights.rectArea.length,
        numHemiLights: lights.hemi.length,
        numDirLightShadows: lights.directionalShadowMap.length,
        numPointLightShadows: lights.pointShadowMap.length,
        numSpotLightShadows: lights.spotShadowMap.length,
        numClippingPlanes: clipping.numPlanes,
        numClipIntersection: clipping.numIntersection,
        dithering: material.dithering,
        shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,
        shadowMapType: renderer.shadowMap.type,
        toneMapping: material.toneMapped ? renderer.toneMapping : NoToneMapping,
        physicallyCorrectLights: renderer.physicallyCorrectLights,
        premultipliedAlpha: material.premultipliedAlpha,
        alphaTest: material.alphaTest,
        doubleSided: material.side === DoubleSide,
        flipSided: material.side === BackSide,
        depthPacking: material.depthPacking !== undefined ? material.depthPacking : false,
        index0AttributeName: material.index0AttributeName,
        extensionDerivatives: material.extensions && material.extensions.derivatives,
        extensionFragDepth: material.extensions && material.extensions.fragDepth,
        extensionDrawBuffers: material.extensions && material.extensions.drawBuffers,
        extensionShaderTextureLOD: material.extensions && material.extensions.shaderTextureLOD,
        rendererExtensionFragDepth: isWebGL2 || extensions.has('EXT_frag_depth'),
        rendererExtensionDrawBuffers: isWebGL2 || extensions.has('WEBGL_draw_buffers'),
        rendererExtensionShaderTextureLod: isWebGL2 || extensions.has('EXT_shader_texture_lod'),
        customProgramCacheKey: material.customProgramCacheKey()
      }
      return parameters
    }

    function getProgramCacheKey(parameters) {
      var array = []

      if (parameters.shaderID) {
        array.push(parameters.shaderID)
      } else {
        array.push(parameters.fragmentShader)
        array.push(parameters.vertexShader)
      }

      if (parameters.defines !== undefined) {
        for (var name in parameters.defines) {
          array.push(name)
          array.push(parameters.defines[name])
        }
      }

      if (parameters.isRawShaderMaterial === false) {
        for (var i = 0; i < parameterNames.length; i++) {
          array.push(parameters[parameterNames[i]])
        }

        array.push(renderer.outputEncoding)
        array.push(renderer.gammaFactor)
      }

      array.push(parameters.customProgramCacheKey)
      return array.join()
    }

    function getUniforms(material) {
      var shaderID = shaderIDs[material.type]
      var uniforms

      if (shaderID) {
        var shader = ShaderLib[shaderID]
        uniforms = UniformsUtils.clone(shader.uniforms)
      } else {
        uniforms = material.uniforms
      }

      return uniforms
    }

    function acquireProgram(parameters, cacheKey) {
      var program // Check if code has been already compiled

      for (var p = 0, pl = programs.length; p < pl; p++) {
        var preexistingProgram = programs[p]

        if (preexistingProgram.cacheKey === cacheKey) {
          program = preexistingProgram
          ++program.usedTimes
          break
        }
      }

      if (program === undefined) {
        program = new WebGLProgram(renderer, cacheKey, parameters, bindingStates)
        programs.push(program)
      }

      return program
    }

    function releaseProgram(program) {
      if (--program.usedTimes === 0) {
        // Remove from unordered set
        var i = programs.indexOf(program)
        programs[i] = programs[programs.length - 1]
        programs.pop() // Free WebGL resources

        program.destroy()
      }
    }

    return {
      getParameters: getParameters,
      getProgramCacheKey: getProgramCacheKey,
      getUniforms: getUniforms,
      acquireProgram: acquireProgram,
      releaseProgram: releaseProgram,
      // Exposed for resource monitoring & error feedback via renderer.info:
      programs: programs
    }
  }

  function WebGLProperties() {
    var properties = new WeakMap()

    function get(object) {
      var 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 {
      get: get,
      remove: remove,
      update: update,
      dispose: dispose
    }
  }

  function 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.program !== b.program) {
      return a.program.id - b.program.id
    } 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 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 WebGLRenderList(properties) {
    var renderItems = []
    var renderItemsIndex = 0
    var opaque = []
    var transparent = []
    var defaultProgram = {
      id: -1
    }

    function init() {
      renderItemsIndex = 0
      opaque.length = 0
      transparent.length = 0
    }

    function getNextRenderItem(object, geometry, material, groupOrder, z, group) {
      var renderItem = renderItems[renderItemsIndex]
      var materialProperties = properties.get(material)

      if (renderItem === undefined) {
        renderItem = {
          id: object.id,
          object: object,
          geometry: geometry,
          material: material,
          program: materialProperties.program || defaultProgram,
          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.program = materialProperties.program || defaultProgram
        renderItem.groupOrder = groupOrder
        renderItem.renderOrder = object.renderOrder
        renderItem.z = z
        renderItem.group = group
      }

      renderItemsIndex++
      return renderItem
    }

    function push(object, geometry, material, groupOrder, z, group) {
      var renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group)
      ;(material.transparent === true ? transparent : opaque).push(renderItem)
    }

    function unshift(object, geometry, material, groupOrder, z, group) {
      var renderItem = getNextRenderItem(object, geometry, material, groupOrder, z, group)
      ;(material.transparent === true ? transparent : opaque).unshift(renderItem)
    }

    function sort(customOpaqueSort, customTransparentSort) {
      if (opaque.length > 1) opaque.sort(customOpaqueSort || painterSortStable)
      if (transparent.length > 1) transparent.sort(customTransparentSort || reversePainterSortStable)
    }

    function finish() {
      // Clear references from inactive renderItems in the list
      for (var i = renderItemsIndex, il = renderItems.length; i < il; i++) {
        var renderItem = renderItems[i]
        if (renderItem.id === null) break
        renderItem.id = null
        renderItem.object = null
        renderItem.geometry = null
        renderItem.material = null
        renderItem.program = null
        renderItem.group = null
      }
    }

    return {
      opaque: opaque,
      transparent: transparent,
      init: init,
      push: push,
      unshift: unshift,
      finish: finish,
      sort: sort
    }
  }

  function WebGLRenderLists(properties) {
    var lists = new WeakMap()

    function get(scene, camera) {
      var cameras = lists.get(scene)
      var list

      if (cameras === undefined) {
        list = new WebGLRenderList(properties)
        lists.set(scene, new WeakMap())
        lists.get(scene).set(camera, list)
      } else {
        list = cameras.get(camera)

        if (list === undefined) {
          list = new WebGLRenderList(properties)
          cameras.set(camera, list)
        }
      }

      return list
    }

    function dispose() {
      lists = new WeakMap()
    }

    return {
      get: get,
      dispose: dispose
    }
  }

  function UniformsCache() {
    var lights = {}
    return {
      get: function get(light) {
        if (lights[light.id] !== undefined) {
          return lights[light.id]
        }

        var uniforms

        switch (light.type) {
          case 'DirectionalLight':
            uniforms = {
              direction: new Vector3(),
              color: new Color()
            }
            break

          case 'SpotLight':
            uniforms = {
              position: new Vector3(),
              direction: new Vector3(),
              color: new Color(),
              distance: 0,
              coneCos: 0,
              penumbraCos: 0,
              decay: 0
            }
            break

          case 'PointLight':
            uniforms = {
              position: new Vector3(),
              color: new Color(),
              distance: 0,
              decay: 0
            }
            break

          case 'HemisphereLight':
            uniforms = {
              direction: new Vector3(),
              skyColor: new Color(),
              groundColor: new Color()
            }
            break

          case 'RectAreaLight':
            uniforms = {
              color: new Color(),
              position: new Vector3(),
              halfWidth: new Vector3(),
              halfHeight: new Vector3()
            }
            break
        }

        lights[light.id] = uniforms
        return uniforms
      }
    }
  }

  function ShadowUniformsCache() {
    var lights = {}
    return {
      get: function get(light) {
        if (lights[light.id] !== undefined) {
          return lights[light.id]
        }

        var uniforms

        switch (light.type) {
          case 'DirectionalLight':
            uniforms = {
              shadowBias: 0,
              shadowNormalBias: 0,
              shadowRadius: 1,
              shadowMapSize: new Vector2()
            }
            break

          case 'SpotLight':
            uniforms = {
              shadowBias: 0,
              shadowNormalBias: 0,
              shadowRadius: 1,
              shadowMapSize: new Vector2()
            }
            break

          case 'PointLight':
            uniforms = {
              shadowBias: 0,
              shadowNormalBias: 0,
              shadowRadius: 1,
              shadowMapSize: new Vector2(),
              shadowCameraNear: 1,
              shadowCameraFar: 1000
            }
            break
          // TODO (abelnation): set RectAreaLight shadow uniforms
        }

        lights[light.id] = uniforms
        return uniforms
      }
    }
  }

  var nextVersion = 0

  function shadowCastingLightsFirst(lightA, lightB) {
    return (lightB.castShadow ? 1 : 0) - (lightA.castShadow ? 1 : 0)
  }

  function WebGLLights(extensions, capabilities) {
    var cache = new UniformsCache()
    var shadowCache = ShadowUniformsCache()
    var state = {
      version: 0,
      hash: {
        directionalLength: -1,
        pointLength: -1,
        spotLength: -1,
        rectAreaLength: -1,
        hemiLength: -1,
        numDirectionalShadows: -1,
        numPointShadows: -1,
        numSpotShadows: -1
      },
      ambient: [0, 0, 0],
      probe: [],
      directional: [],
      directionalShadow: [],
      directionalShadowMap: [],
      directionalShadowMatrix: [],
      spot: [],
      spotShadow: [],
      spotShadowMap: [],
      spotShadowMatrix: [],
      rectArea: [],
      rectAreaLTC1: null,
      rectAreaLTC2: null,
      point: [],
      pointShadow: [],
      pointShadowMap: [],
      pointShadowMatrix: [],
      hemi: []
    }

    for (var i = 0; i < 9; i++) {
      state.probe.push(new Vector3())
    }

    var vector3 = new Vector3()
    var matrix4 = new Matrix4()
    var matrix42 = new Matrix4()

    function setup(lights) {
      var r = 0,
        g = 0,
        b = 0

      for (var _i = 0; _i < 9; _i++) {
        state.probe[_i].set(0, 0, 0)
      }

      var directionalLength = 0
      var pointLength = 0
      var spotLength = 0
      var rectAreaLength = 0
      var hemiLength = 0
      var numDirectionalShadows = 0
      var numPointShadows = 0
      var numSpotShadows = 0
      lights.sort(shadowCastingLightsFirst)

      for (var _i2 = 0, l = lights.length; _i2 < l; _i2++) {
        var light = lights[_i2]
        var color = light.color
        var intensity = light.intensity
        var distance = light.distance
        var 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 (var j = 0; j < 9; j++) {
            state.probe[j].addScaledVector(light.sh.coefficients[j], intensity)
          }
        } else if (light.isDirectionalLight) {
          var uniforms = cache.get(light)
          uniforms.color.copy(light.color).multiplyScalar(light.intensity)

          if (light.castShadow) {
            var shadow = light.shadow
            var shadowUniforms = shadowCache.get(light)
            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) {
          var _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

          if (light.castShadow) {
            var _shadow = light.shadow

            var _shadowUniforms = shadowCache.get(light)

            _shadowUniforms.shadowBias = _shadow.bias
            _shadowUniforms.shadowNormalBias = _shadow.normalBias
            _shadowUniforms.shadowRadius = _shadow.radius
            _shadowUniforms.shadowMapSize = _shadow.mapSize
            state.spotShadow[spotLength] = _shadowUniforms
            state.spotShadowMap[spotLength] = shadowMap
            state.spotShadowMatrix[spotLength] = light.shadow.matrix
            numSpotShadows++
          }

          state.spot[spotLength] = _uniforms
          spotLength++
        } else if (light.isRectAreaLight) {
          var _uniforms2 = cache.get(light) // (a) intensity is the total visible light emitted
          //uniforms.color.copy( color ).multiplyScalar( intensity / ( light.width * light.height * Math.PI ) );
          // (b) intensity is the brightness of the light

          _uniforms2.color.copy(color).multiplyScalar(intensity)

          _uniforms2.halfWidth.set(light.width * 0.5, 0.0, 0.0)

          _uniforms2.halfHeight.set(0.0, light.height * 0.5, 0.0)

          state.rectArea[rectAreaLength] = _uniforms2
          rectAreaLength++
        } else if (light.isPointLight) {
          var _uniforms3 = cache.get(light)

          _uniforms3.color.copy(light.color).multiplyScalar(light.intensity)

          _uniforms3.distance = light.distance
          _uniforms3.decay = light.decay

          if (light.castShadow) {
            var _shadow2 = light.shadow

            var _shadowUniforms2 = shadowCache.get(light)

            _shadowUniforms2.shadowBias = _shadow2.bias
            _shadowUniforms2.shadowNormalBias = _shadow2.normalBias
            _shadowUniforms2.shadowRadius = _shadow2.radius
            _shadowUniforms2.shadowMapSize = _shadow2.mapSize
            _shadowUniforms2.shadowCameraNear = _shadow2.camera.near
            _shadowUniforms2.shadowCameraFar = _shadow2.camera.far
            state.pointShadow[pointLength] = _shadowUniforms2
            state.pointShadowMap[pointLength] = shadowMap
            state.pointShadowMatrix[pointLength] = light.shadow.matrix
            numPointShadows++
          }

          state.point[pointLength] = _uniforms3
          pointLength++
        } else if (light.isHemisphereLight) {
          var _uniforms4 = cache.get(light)

          _uniforms4.skyColor.copy(light.color).multiplyScalar(intensity)

          _uniforms4.groundColor.copy(light.groundColor).multiplyScalar(intensity)

          state.hemi[hemiLength] = _uniforms4
          hemiLength++
        }
      }

      if (rectAreaLength > 0) {
        if (capabilities.isWebGL2) {
          // WebGL 2
          state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1
          state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2
        } else {
          // WebGL 1
          if (extensions.has('OES_texture_float_linear') === true) {
            state.rectAreaLTC1 = UniformsLib.LTC_FLOAT_1
            state.rectAreaLTC2 = UniformsLib.LTC_FLOAT_2
          } else if (extensions.has('OES_texture_half_float_linear') === true) {
            state.rectAreaLTC1 = UniformsLib.LTC_HALF_1
            state.rectAreaLTC2 = UniformsLib.LTC_HALF_2
          } else {
            console.error('THREE.WebGLRenderer: Unable to use RectAreaLight. Missing WebGL extensions.')
          }
        }
      }

      state.ambient[0] = r
      state.ambient[1] = g
      state.ambient[2] = b
      var 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
      ) {
        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.spotShadowMatrix.length = numSpotShadows
        hash.directionalLength = directionalLength
        hash.pointLength = pointLength
        hash.spotLength = spotLength
        hash.rectAreaLength = rectAreaLength
        hash.hemiLength = hemiLength
        hash.numDirectionalShadows = numDirectionalShadows
        hash.numPointShadows = numPointShadows
        hash.numSpotShadows = numSpotShadows
        state.version = nextVersion++
      }
    }

    function setupView(lights, camera) {
      var directionalLength = 0
      var pointLength = 0
      var spotLength = 0
      var rectAreaLength = 0
      var hemiLength = 0
      var viewMatrix = camera.matrixWorldInverse

      for (var _i3 = 0, l = lights.length; _i3 < l; _i3++) {
        var light = lights[_i3]

        if (light.isDirectionalLight) {
          var 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) {
          var _uniforms5 = state.spot[spotLength]

          _uniforms5.position.setFromMatrixPosition(light.matrixWorld)

          _uniforms5.position.applyMatrix4(viewMatrix)

          _uniforms5.direction.setFromMatrixPosition(light.matrixWorld)

          vector3.setFromMatrixPosition(light.target.matrixWorld)

          _uniforms5.direction.sub(vector3)

          _uniforms5.direction.transformDirection(viewMatrix)

          spotLength++
        } else if (light.isRectAreaLight) {
          var _uniforms6 = state.rectArea[rectAreaLength]

          _uniforms6.position.setFromMatrixPosition(light.matrixWorld)

          _uniforms6.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)

          _uniforms6.halfWidth.set(light.width * 0.5, 0.0, 0.0)

          _uniforms6.halfHeight.set(0.0, light.height * 0.5, 0.0)

          _uniforms6.halfWidth.applyMatrix4(matrix42)

          _uniforms6.halfHeight.applyMatrix4(matrix42)

          rectAreaLength++
        } else if (light.isPointLight) {
          var _uniforms7 = state.point[pointLength]

          _uniforms7.position.setFromMatrixPosition(light.matrixWorld)

          _uniforms7.position.applyMatrix4(viewMatrix)

          pointLength++
        } else if (light.isHemisphereLight) {
          var _uniforms8 = state.hemi[hemiLength]

          _uniforms8.direction.setFromMatrixPosition(light.matrixWorld)

          _uniforms8.direction.transformDirection(viewMatrix)

          _uniforms8.direction.normalize()

          hemiLength++
        }
      }
    }

    return {
      setup: setup,
      setupView: setupView,
      state: state
    }
  }

  function WebGLRenderState(extensions, capabilities) {
    var lights = new WebGLLights(extensions, capabilities)
    var lightsArray = []
    var shadowsArray = []

    function init() {
      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)
    }

    var state = {
      lightsArray: lightsArray,
      shadowsArray: shadowsArray,
      lights: lights
    }
    return {
      init: init,
      state: state,
      setupLights: setupLights,
      setupLightsView: setupLightsView,
      pushLight: pushLight,
      pushShadow: pushShadow
    }
  }

  function WebGLRenderStates(extensions, capabilities) {
    var renderStates = new WeakMap()

    function get(scene, renderCallDepth) {
      if (renderCallDepth === void 0) {
        renderCallDepth = 0
      }

      var renderState

      if (renderStates.has(scene) === false) {
        renderState = new WebGLRenderState(extensions, capabilities)
        renderStates.set(scene, [])
        renderStates.get(scene).push(renderState)
      } else {
        if (renderCallDepth >= renderStates.get(scene).length) {
          renderState = new WebGLRenderState(extensions, capabilities)
          renderStates.get(scene).push(renderState)
        } else {
          renderState = renderStates.get(scene)[renderCallDepth]
        }
      }

      return renderState
    }

    function dispose() {
      renderStates = new WeakMap()
    }

    return {
      get: get,
      dispose: dispose
    }
  }

  /**
   * parameters = {
   *
   *	opacity: <float>,
   *
   *	map: new THREE.Texture( <Image> ),
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>
   * }
   */

  function MeshDepthMaterial(parameters) {
    Material.call(this)
    this.type = 'MeshDepthMaterial'
    this.depthPacking = BasicDepthPacking
    this.skinning = false
    this.morphTargets = false
    this.map = null
    this.alphaMap = null
    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0
    this.wireframe = false
    this.wireframeLinewidth = 1
    this.fog = false
    this.setValues(parameters)
  }

  MeshDepthMaterial.prototype = Object.create(Material.prototype)
  MeshDepthMaterial.prototype.constructor = MeshDepthMaterial
  MeshDepthMaterial.prototype.isMeshDepthMaterial = true

  MeshDepthMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.depthPacking = source.depthPacking
    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    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
  }

  /**
   * parameters = {
   *
   *	referencePosition: <float>,
   *	nearDistance: <float>,
   *	farDistance: <float>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *
   *	map: new THREE.Texture( <Image> ),
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>
   *
   * }
   */

  function MeshDistanceMaterial(parameters) {
    Material.call(this)
    this.type = 'MeshDistanceMaterial'
    this.referencePosition = new Vector3()
    this.nearDistance = 1
    this.farDistance = 1000
    this.skinning = false
    this.morphTargets = false
    this.map = null
    this.alphaMap = null
    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0
    this.fog = false
    this.setValues(parameters)
  }

  MeshDistanceMaterial.prototype = Object.create(Material.prototype)
  MeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial
  MeshDistanceMaterial.prototype.isMeshDistanceMaterial = true

  MeshDistanceMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.referencePosition.copy(source.referencePosition)
    this.nearDistance = source.nearDistance
    this.farDistance = source.farDistance
    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.map = source.map
    this.alphaMap = source.alphaMap
    this.displacementMap = source.displacementMap
    this.displacementScale = source.displacementScale
    this.displacementBias = source.displacementBias
    return this
  }

  var vsm_frag =
    'uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include <packing>\nvoid main() {\n\tfloat mean = 0.0;\n\tfloat squared_mean = 0.0;\n\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy ) / resolution ) );\n\tfor ( float i = -1.0; i < 1.0 ; i += SAMPLE_RATE) {\n\t\t#ifdef HORIZONAL_PASS\n\t\t\tvec2 distribution = unpackRGBATo2Half( texture2D( shadow_pass, ( gl_FragCoord.xy + vec2( i, 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, i ) * radius ) / resolution ) );\n\t\t\tmean += depth;\n\t\t\tsquared_mean += depth * depth;\n\t\t#endif\n\t}\n\tmean = mean * HALF_SAMPLE_RATE;\n\tsquared_mean = squared_mean * HALF_SAMPLE_RATE;\n\tfloat std_dev = sqrt( squared_mean - mean * mean );\n\tgl_FragColor = pack2HalfToRGBA( vec2( mean, std_dev ) );\n}'

  var vsm_vert = 'void main() {\n\tgl_Position = vec4( position, 1.0 );\n}'

  function WebGLShadowMap(_renderer, _objects, maxTextureSize) {
    var _frustum = new Frustum()

    var _shadowMapSize = new Vector2(),
      _viewportSize = new Vector2(),
      _viewport = new Vector4(),
      _depthMaterials = [],
      _distanceMaterials = [],
      _materialCache = {}

    var shadowSide = {
      0: BackSide,
      1: FrontSide,
      2: DoubleSide
    }
    var shadowMaterialVertical = new ShaderMaterial({
      defines: {
        SAMPLE_RATE: 2.0 / 8.0,
        HALF_SAMPLE_RATE: 1.0 / 8.0
      },
      uniforms: {
        shadow_pass: {
          value: null
        },
        resolution: {
          value: new Vector2()
        },
        radius: {
          value: 4.0
        }
      },
      vertexShader: vsm_vert,
      fragmentShader: vsm_frag
    })
    var shadowMaterialHorizonal = shadowMaterialVertical.clone()
    shadowMaterialHorizonal.defines.HORIZONAL_PASS = 1
    var fullScreenTri = new BufferGeometry()
    fullScreenTri.setAttribute('position', new BufferAttribute(new Float32Array([-1, -1, 0.5, 3, -1, 0.5, -1, 3, 0.5]), 3))
    var fullScreenMesh = new Mesh(fullScreenTri, shadowMaterialVertical)
    var scope = this
    this.enabled = false
    this.autoUpdate = true
    this.needsUpdate = false
    this.type = PCFShadowMap

    this.render = function (lights, scene, camera) {
      if (scope.enabled === false) return
      if (scope.autoUpdate === false && scope.needsUpdate === false) return
      if (lights.length === 0) return

      var currentRenderTarget = _renderer.getRenderTarget()

      var activeCubeFace = _renderer.getActiveCubeFace()

      var activeMipmapLevel = _renderer.getActiveMipmapLevel()

      var _state = _renderer.state // Set GL state for depth map.

      _state.setBlending(NoBlending)

      _state.buffers.color.setClear(1, 1, 1, 1)

      _state.buffers.depth.setTest(true)

      _state.setScissorTest(false) // render depth map

      for (var i = 0, il = lights.length; i < il; i++) {
        var light = lights[i]
        var 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)

        var 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 && !shadow.isPointLightShadow && this.type === VSMShadowMap) {
          var pars = {
            minFilter: LinearFilter,
            magFilter: LinearFilter,
            format: RGBAFormat
          }
          shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars)
          shadow.map.texture.name = light.name + '.shadowMap'
          shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars)
          shadow.camera.updateProjectionMatrix()
        }

        if (shadow.map === null) {
          var _pars = {
            minFilter: NearestFilter,
            magFilter: NearestFilter,
            format: RGBAFormat
          }
          shadow.map = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, _pars)
          shadow.map.texture.name = light.name + '.shadowMap'
          shadow.camera.updateProjectionMatrix()
        }

        _renderer.setRenderTarget(shadow.map)

        _renderer.clear()

        var viewportCount = shadow.getViewportCount()

        for (var vp = 0; vp < viewportCount; vp++) {
          var 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 && this.type === VSMShadowMap) {
          VSMPass(shadow, camera)
        }

        shadow.needsUpdate = false
      }

      scope.needsUpdate = false

      _renderer.setRenderTarget(currentRenderTarget, activeCubeFace, activeMipmapLevel)
    }

    function VSMPass(shadow, camera) {
      var geometry = _objects.update(fullScreenMesh) // 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) // horizonal pass

      shadowMaterialHorizonal.uniforms.shadow_pass.value = shadow.mapPass.texture
      shadowMaterialHorizonal.uniforms.resolution.value = shadow.mapSize
      shadowMaterialHorizonal.uniforms.radius.value = shadow.radius

      _renderer.setRenderTarget(shadow.map)

      _renderer.clear()

      _renderer.renderBufferDirect(camera, null, geometry, shadowMaterialHorizonal, fullScreenMesh, null)
    }

    function getDepthMaterialVariant(useMorphing, useSkinning, useInstancing) {
      var index = (useMorphing << 0) | (useSkinning << 1) | (useInstancing << 2)
      var material = _depthMaterials[index]

      if (material === undefined) {
        material = new MeshDepthMaterial({
          depthPacking: RGBADepthPacking,
          morphTargets: useMorphing,
          skinning: useSkinning
        })
        _depthMaterials[index] = material
      }

      return material
    }

    function getDistanceMaterialVariant(useMorphing, useSkinning, useInstancing) {
      var index = (useMorphing << 0) | (useSkinning << 1) | (useInstancing << 2)
      var material = _distanceMaterials[index]

      if (material === undefined) {
        material = new MeshDistanceMaterial({
          morphTargets: useMorphing,
          skinning: useSkinning
        })
        _distanceMaterials[index] = material
      }

      return material
    }

    function getDepthMaterial(object, geometry, material, light, shadowCameraNear, shadowCameraFar, type) {
      var result = null
      var getMaterialVariant = getDepthMaterialVariant
      var customMaterial = object.customDepthMaterial

      if (light.isPointLight === true) {
        getMaterialVariant = getDistanceMaterialVariant
        customMaterial = object.customDistanceMaterial
      }

      if (customMaterial === undefined) {
        var useMorphing = false

        if (material.morphTargets === true) {
          useMorphing = geometry.morphAttributes && geometry.morphAttributes.position && geometry.morphAttributes.position.length > 0
        }

        var useSkinning = false

        if (object.isSkinnedMesh === true) {
          if (material.skinning === true) {
            useSkinning = true
          } else {
            console.warn('THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:', object)
          }
        }

        var useInstancing = object.isInstancedMesh === true
        result = getMaterialVariant(useMorphing, useSkinning, useInstancing)
      } else {
        result = customMaterial
      }

      if (_renderer.localClippingEnabled && material.clipShadows === true && material.clippingPlanes.length !== 0) {
        // in this case we need a unique material instance reflecting the
        // appropriate state
        var keyA = result.uuid,
          keyB = material.uuid
        var materialsForVariant = _materialCache[keyA]

        if (materialsForVariant === undefined) {
          materialsForVariant = {}
          _materialCache[keyA] = materialsForVariant
        }

        var cachedMaterial = materialsForVariant[keyB]

        if (cachedMaterial === undefined) {
          cachedMaterial = result.clone()
          materialsForVariant[keyB] = cachedMaterial
        }

        result = cachedMaterial
      }

      result.visible = material.visible
      result.wireframe = material.wireframe

      if (type === VSMShadowMap) {
        result.side = material.shadowSide !== null ? material.shadowSide : material.side
      } else {
        result.side = material.shadowSide !== null ? material.shadowSide : shadowSide[material.side]
      }

      result.clipShadows = material.clipShadows
      result.clippingPlanes = material.clippingPlanes
      result.clipIntersection = material.clipIntersection
      result.wireframeLinewidth = material.wireframeLinewidth
      result.linewidth = material.linewidth

      if (light.isPointLight === true && result.isMeshDistanceMaterial === true) {
        result.referencePosition.setFromMatrixPosition(light.matrixWorld)
        result.nearDistance = shadowCameraNear
        result.farDistance = shadowCameraFar
      }

      return result
    }

    function renderObject(object, camera, shadowCamera, light, type) {
      if (object.visible === false) return
      var visible = object.layers.test(camera.layers)

      if (visible && (object.isMesh || object.isLine || object.isPoints)) {
        if ((object.castShadow || (object.receiveShadow && type === VSMShadowMap)) && (!object.frustumCulled || _frustum.intersectsObject(object))) {
          object.modelViewMatrix.multiplyMatrices(shadowCamera.matrixWorldInverse, object.matrixWorld)

          var geometry = _objects.update(object)

          var material = object.material

          if (Array.isArray(material)) {
            var groups = geometry.groups

            for (var k = 0, kl = groups.length; k < kl; k++) {
              var group = groups[k]
              var groupMaterial = material[group.materialIndex]

              if (groupMaterial && groupMaterial.visible) {
                var depthMaterial = getDepthMaterial(object, geometry, groupMaterial, light, shadowCamera.near, shadowCamera.far, type)

                _renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group)
              }
            }
          } else if (material.visible) {
            var _depthMaterial = getDepthMaterial(object, geometry, material, light, shadowCamera.near, shadowCamera.far, type)

            _renderer.renderBufferDirect(shadowCamera, null, geometry, _depthMaterial, object, null)
          }
        }
      }

      var children = object.children

      for (var i = 0, l = children.length; i < l; i++) {
        renderObject(children[i], camera, shadowCamera, light, type)
      }
    }
  }

  function WebGLState(gl, extensions, capabilities) {
    var _equationToGL, _factorToGL

    var isWebGL2 = capabilities.isWebGL2

    function ColorBuffer() {
      var locked = false
      var color = new Vector4()
      var currentColorMask = null
      var currentColorClear = new Vector4(0, 0, 0, 0)
      return {
        setMask: function setMask(colorMask) {
          if (currentColorMask !== colorMask && !locked) {
            gl.colorMask(colorMask, colorMask, colorMask, colorMask)
            currentColorMask = colorMask
          }
        },
        setLocked: function setLocked(lock) {
          locked = lock
        },
        setClear: function setClear(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 reset() {
          locked = false
          currentColorMask = null
          currentColorClear.set(-1, 0, 0, 0) // set to invalid state
        }
      }
    }

    function DepthBuffer() {
      var locked = false
      var currentDepthMask = null
      var currentDepthFunc = null
      var currentDepthClear = null
      return {
        setTest: function setTest(depthTest) {
          if (depthTest) {
            enable(2929)
          } else {
            disable(2929)
          }
        },
        setMask: function setMask(depthMask) {
          if (currentDepthMask !== depthMask && !locked) {
            gl.depthMask(depthMask)
            currentDepthMask = depthMask
          }
        },
        setFunc: function setFunc(depthFunc) {
          if (currentDepthFunc !== depthFunc) {
            if (depthFunc) {
              switch (depthFunc) {
                case NeverDepth:
                  gl.depthFunc(512)
                  break

                case AlwaysDepth:
                  gl.depthFunc(519)
                  break

                case LessDepth:
                  gl.depthFunc(513)
                  break

                case LessEqualDepth:
                  gl.depthFunc(515)
                  break

                case EqualDepth:
                  gl.depthFunc(514)
                  break

                case GreaterEqualDepth:
                  gl.depthFunc(518)
                  break

                case GreaterDepth:
                  gl.depthFunc(516)
                  break

                case NotEqualDepth:
                  gl.depthFunc(517)
                  break

                default:
                  gl.depthFunc(515)
              }
            } else {
              gl.depthFunc(515)
            }

            currentDepthFunc = depthFunc
          }
        },
        setLocked: function setLocked(lock) {
          locked = lock
        },
        setClear: function setClear(depth) {
          if (currentDepthClear !== depth) {
            gl.clearDepth(depth)
            currentDepthClear = depth
          }
        },
        reset: function reset() {
          locked = false
          currentDepthMask = null
          currentDepthFunc = null
          currentDepthClear = null
        }
      }
    }

    function StencilBuffer() {
      var locked = false
      var currentStencilMask = null
      var currentStencilFunc = null
      var currentStencilRef = null
      var currentStencilFuncMask = null
      var currentStencilFail = null
      var currentStencilZFail = null
      var currentStencilZPass = null
      var currentStencilClear = null
      return {
        setTest: function setTest(stencilTest) {
          if (!locked) {
            if (stencilTest) {
              enable(2960)
            } else {
              disable(2960)
            }
          }
        },
        setMask: function setMask(stencilMask) {
          if (currentStencilMask !== stencilMask && !locked) {
            gl.stencilMask(stencilMask)
            currentStencilMask = stencilMask
          }
        },
        setFunc: function setFunc(stencilFunc, stencilRef, stencilMask) {
          if (currentStencilFunc !== stencilFunc || currentStencilRef !== stencilRef || currentStencilFuncMask !== stencilMask) {
            gl.stencilFunc(stencilFunc, stencilRef, stencilMask)
            currentStencilFunc = stencilFunc
            currentStencilRef = stencilRef
            currentStencilFuncMask = stencilMask
          }
        },
        setOp: function setOp(stencilFail, stencilZFail, stencilZPass) {
          if (currentStencilFail !== stencilFail || currentStencilZFail !== stencilZFail || currentStencilZPass !== stencilZPass) {
            gl.stencilOp(stencilFail, stencilZFail, stencilZPass)
            currentStencilFail = stencilFail
            currentStencilZFail = stencilZFail
            currentStencilZPass = stencilZPass
          }
        },
        setLocked: function setLocked(lock) {
          locked = lock
        },
        setClear: function setClear(stencil) {
          if (currentStencilClear !== stencil) {
            gl.clearStencil(stencil)
            currentStencilClear = stencil
          }
        },
        reset: function reset() {
          locked = false
          currentStencilMask = null
          currentStencilFunc = null
          currentStencilRef = null
          currentStencilFuncMask = null
          currentStencilFail = null
          currentStencilZFail = null
          currentStencilZPass = null
          currentStencilClear = null
        }
      }
    } //

    var colorBuffer = new ColorBuffer()
    var depthBuffer = new DepthBuffer()
    var stencilBuffer = new StencilBuffer()
    var enabledCapabilities = {}
    var currentProgram = null
    var currentBlendingEnabled = null
    var currentBlending = null
    var currentBlendEquation = null
    var currentBlendSrc = null
    var currentBlendDst = null
    var currentBlendEquationAlpha = null
    var currentBlendSrcAlpha = null
    var currentBlendDstAlpha = null
    var currentPremultipledAlpha = false
    var currentFlipSided = null
    var currentCullFace = null
    var currentLineWidth = null
    var currentPolygonOffsetFactor = null
    var currentPolygonOffsetUnits = null
    var maxTextures = gl.getParameter(35661)
    var lineWidthAvailable = false
    var version = 0
    var glVersion = gl.getParameter(7938)

    if (glVersion.indexOf('WebGL') !== -1) {
      version = parseFloat(/^WebGL\ ([0-9])/.exec(glVersion)[1])
      lineWidthAvailable = version >= 1.0
    } else if (glVersion.indexOf('OpenGL ES') !== -1) {
      version = parseFloat(/^OpenGL\ ES\ ([0-9])/.exec(glVersion)[1])
      lineWidthAvailable = version >= 2.0
    }

    var currentTextureSlot = null
    var currentBoundTextures = {}
    var currentScissor = new Vector4()
    var currentViewport = new Vector4()

    function createTexture(type, target, count) {
      var data = new Uint8Array(4) // 4 is required to match default unpack alignment of 4.

      var texture = gl.createTexture()
      gl.bindTexture(type, texture)
      gl.texParameteri(type, 10241, 9728)
      gl.texParameteri(type, 10240, 9728)

      for (var i = 0; i < count; i++) {
        gl.texImage2D(target + i, 0, 6408, 1, 1, 0, 6408, 5121, data)
      }

      return texture
    }

    var emptyTextures = {}
    emptyTextures[3553] = createTexture(3553, 3553, 1)
    emptyTextures[34067] = createTexture(34067, 34069, 6) // init

    colorBuffer.setClear(0, 0, 0, 1)
    depthBuffer.setClear(1)
    stencilBuffer.setClear(0)
    enable(2929)
    depthBuffer.setFunc(LessEqualDepth)
    setFlipSided(false)
    setCullFace(CullFaceBack)
    enable(2884)
    setBlending(NoBlending) //

    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 useProgram(program) {
      if (currentProgram !== program) {
        gl.useProgram(program)
        currentProgram = program
        return true
      }

      return false
    }

    var equationToGL =
      ((_equationToGL = {}),
      (_equationToGL[AddEquation] = 32774),
      (_equationToGL[SubtractEquation] = 32778),
      (_equationToGL[ReverseSubtractEquation] = 32779),
      _equationToGL)

    if (isWebGL2) {
      equationToGL[MinEquation] = 32775
      equationToGL[MaxEquation] = 32776
    } else {
      var extension = extensions.get('EXT_blend_minmax')

      if (extension !== null) {
        equationToGL[MinEquation] = extension.MIN_EXT
        equationToGL[MaxEquation] = extension.MAX_EXT
      }
    }

    var factorToGL =
      ((_factorToGL = {}),
      (_factorToGL[ZeroFactor] = 0),
      (_factorToGL[OneFactor] = 1),
      (_factorToGL[SrcColorFactor] = 768),
      (_factorToGL[SrcAlphaFactor] = 770),
      (_factorToGL[SrcAlphaSaturateFactor] = 776),
      (_factorToGL[DstColorFactor] = 774),
      (_factorToGL[DstAlphaFactor] = 772),
      (_factorToGL[OneMinusSrcColorFactor] = 769),
      (_factorToGL[OneMinusSrcAlphaFactor] = 771),
      (_factorToGL[OneMinusDstColorFactor] = 775),
      (_factorToGL[OneMinusDstAlphaFactor] = 773),
      _factorToGL)

    function setBlending(blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha) {
      if (blending === NoBlending) {
        if (currentBlendingEnabled) {
          disable(3042)
          currentBlendingEnabled = false
        }

        return
      }

      if (!currentBlendingEnabled) {
        enable(3042)
        currentBlendingEnabled = true
      }

      if (blending !== CustomBlending) {
        if (blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha) {
          if (currentBlendEquation !== AddEquation || currentBlendEquationAlpha !== AddEquation) {
            gl.blendEquation(32774)
            currentBlendEquation = AddEquation
            currentBlendEquationAlpha = AddEquation
          }

          if (premultipliedAlpha) {
            switch (blending) {
              case NormalBlending:
                gl.blendFuncSeparate(1, 771, 1, 771)
                break

              case AdditiveBlending:
                gl.blendFunc(1, 1)
                break

              case SubtractiveBlending:
                gl.blendFuncSeparate(0, 0, 769, 771)
                break

              case MultiplyBlending:
                gl.blendFuncSeparate(0, 768, 0, 770)
                break

              default:
                console.error('THREE.WebGLState: Invalid blending: ', blending)
                break
            }
          } else {
            switch (blending) {
              case NormalBlending:
                gl.blendFuncSeparate(770, 771, 1, 771)
                break

              case AdditiveBlending:
                gl.blendFunc(770, 1)
                break

              case SubtractiveBlending:
                gl.blendFunc(0, 769)
                break

              case MultiplyBlending:
                gl.blendFunc(0, 768)
                break

              default:
                console.error('THREE.WebGLState: Invalid blending: ', blending)
                break
            }
          }

          currentBlendSrc = null
          currentBlendDst = null
          currentBlendSrcAlpha = null
          currentBlendDstAlpha = null
          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
      }

      currentBlending = blending
      currentPremultipledAlpha = null
    }

    function setMaterial(material, frontFaceCW) {
      material.side === DoubleSide ? disable(2884) : enable(2884)
      var flipSided = material.side === BackSide
      if (frontFaceCW) flipSided = !flipSided
      setFlipSided(flipSided)
      material.blending === NormalBlending && material.transparent === false
        ? setBlending(NoBlending)
        : setBlending(
            material.blending,
            material.blendEquation,
            material.blendSrc,
            material.blendDst,
            material.blendEquationAlpha,
            material.blendSrcAlpha,
            material.blendDstAlpha,
            material.premultipliedAlpha
          )
      depthBuffer.setFunc(material.depthFunc)
      depthBuffer.setTest(material.depthTest)
      depthBuffer.setMask(material.depthWrite)
      colorBuffer.setMask(material.colorWrite)
      var 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)
    } //

    function setFlipSided(flipSided) {
      if (currentFlipSided !== flipSided) {
        if (flipSided) {
          gl.frontFace(2304)
        } else {
          gl.frontFace(2305)
        }

        currentFlipSided = flipSided
      }
    }

    function setCullFace(cullFace) {
      if (cullFace !== CullFaceNone) {
        enable(2884)

        if (cullFace !== currentCullFace) {
          if (cullFace === CullFaceBack) {
            gl.cullFace(1029)
          } else if (cullFace === CullFaceFront) {
            gl.cullFace(1028)
          } else {
            gl.cullFace(1032)
          }
        }
      } else {
        disable(2884)
      }

      currentCullFace = cullFace
    }

    function setLineWidth(width) {
      if (width !== currentLineWidth) {
        if (lineWidthAvailable) gl.lineWidth(width)
        currentLineWidth = width
      }
    }

    function setPolygonOffset(polygonOffset, factor, units) {
      if (polygonOffset) {
        enable(32823)

        if (currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units) {
          gl.polygonOffset(factor, units)
          currentPolygonOffsetFactor = factor
          currentPolygonOffsetUnits = units
        }
      } else {
        disable(32823)
      }
    }

    function setScissorTest(scissorTest) {
      if (scissorTest) {
        enable(3089)
      } else {
        disable(3089)
      }
    } // texture

    function activeTexture(webglSlot) {
      if (webglSlot === undefined) webglSlot = 33984 + maxTextures - 1

      if (currentTextureSlot !== webglSlot) {
        gl.activeTexture(webglSlot)
        currentTextureSlot = webglSlot
      }
    }

    function bindTexture(webglType, webglTexture) {
      if (currentTextureSlot === null) {
        activeTexture()
      }

      var boundTexture = currentBoundTextures[currentTextureSlot]

      if (boundTexture === undefined) {
        boundTexture = {
          type: undefined,
          texture: undefined
        }
        currentBoundTextures[currentTextureSlot] = boundTexture
      }

      if (boundTexture.type !== webglType || boundTexture.texture !== webglTexture) {
        gl.bindTexture(webglType, webglTexture || emptyTextures[webglType])
        boundTexture.type = webglType
        boundTexture.texture = webglTexture
      }
    }

    function unbindTexture() {
      var 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 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 reset() {
      enabledCapabilities = {}
      currentTextureSlot = null
      currentBoundTextures = {}
      currentProgram = null
      currentBlendingEnabled = null
      currentBlending = null
      currentBlendEquation = null
      currentBlendSrc = null
      currentBlendDst = null
      currentBlendEquationAlpha = null
      currentBlendSrcAlpha = null
      currentBlendDstAlpha = null
      currentPremultipledAlpha = false
      currentFlipSided = null
      currentCullFace = null
      currentLineWidth = null
      currentPolygonOffsetFactor = null
      currentPolygonOffsetUnits = null
      colorBuffer.reset()
      depthBuffer.reset()
      stencilBuffer.reset()
    }

    return {
      buffers: {
        color: colorBuffer,
        depth: depthBuffer,
        stencil: stencilBuffer
      },
      enable: enable,
      disable: disable,
      useProgram: useProgram,
      setBlending: setBlending,
      setMaterial: setMaterial,
      setFlipSided: setFlipSided,
      setCullFace: setCullFace,
      setLineWidth: setLineWidth,
      setPolygonOffset: setPolygonOffset,
      setScissorTest: setScissorTest,
      activeTexture: activeTexture,
      bindTexture: bindTexture,
      unbindTexture: unbindTexture,
      compressedTexImage2D: compressedTexImage2D,
      texImage2D: texImage2D,
      texImage3D: texImage3D,
      scissor: scissor,
      viewport: viewport,
      reset: reset
    }
  }

  function WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info) {
    var _wrappingToGL, _filterToGL

    var isWebGL2 = capabilities.isWebGL2
    var maxTextures = capabilities.maxTextures
    var maxCubemapSize = capabilities.maxCubemapSize
    var maxTextureSize = capabilities.maxTextureSize
    var maxSamples = capabilities.maxSamples

    var _videoTextures = new WeakMap()

    var _canvas // 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).

    var 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 ? new OffscreenCanvas(width, height) : document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
    }

    function resizeImage(image, needsPowerOfTwo, needsNewCanvas, maxSize) {
      var scale = 1 // handle case if texture exceeds max size

      if (image.width > maxSize || image.height > maxSize) {
        scale = maxSize / Math.max(image.width, image.height)
      } // only perform resize if necessary

      if (scale < 1 || needsPowerOfTwo === true) {
        // 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)
        ) {
          var floor = needsPowerOfTwo ? MathUtils.floorPowerOfTwo : Math.floor
          var width = floor(scale * image.width)
          var height = floor(scale * image.height)
          if (_canvas === undefined) _canvas = createCanvas(width, height) // cube textures can't reuse the same canvas

          var canvas = needsNewCanvas ? createCanvas(width, height) : _canvas
          canvas.width = width
          canvas.height = height
          var context = canvas.getContext('2d')
          context.drawImage(image, 0, 0, width, height)
          console.warn('THREE.WebGLRenderer: Texture has been resized from (' + image.width + 'x' + image.height + ') to (' + width + 'x' + height + ').')
          return canvas
        } else {
          if ('data' in image) {
            console.warn('THREE.WebGLRenderer: Image in DataTexture is too big (' + image.width + 'x' + image.height + ').')
          }

          return image
        }
      }

      return image
    }

    function isPowerOfTwo(image) {
      return MathUtils.isPowerOfTwo(image.width) && MathUtils.isPowerOfTwo(image.height)
    }

    function textureNeedsPowerOfTwo(texture) {
      if (isWebGL2) return false
      return texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping || (texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter)
    }

    function textureNeedsGenerateMipmaps(texture, supportsMips) {
      return texture.generateMipmaps && supportsMips && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter
    }

    function generateMipmap(target, texture, width, height) {
      _gl.generateMipmap(target)

      var textureProperties = properties.get(texture) // Note: Math.log( x ) * Math.LOG2E used instead of Math.log2( x ) which is not supported by IE11

      textureProperties.__maxMipLevel = Math.log(Math.max(width, height)) * Math.LOG2E
    }

    function getInternalFormat(internalFormatName, glFormat, glType) {
      if (isWebGL2 === false) return glFormat

      if (internalFormatName !== null) {
        if (_gl[internalFormatName] !== undefined) return _gl[internalFormatName]
        console.warn("THREE.WebGLRenderer: Attempt to use non-existing WebGL internal format '" + internalFormatName + "'")
      }

      var internalFormat = glFormat

      if (glFormat === 6403) {
        if (glType === 5126) internalFormat = 33326
        if (glType === 5131) internalFormat = 33325
        if (glType === 5121) internalFormat = 33321
      }

      if (glFormat === 6407) {
        if (glType === 5126) internalFormat = 34837
        if (glType === 5131) internalFormat = 34843
        if (glType === 5121) internalFormat = 32849
      }

      if (glFormat === 6408) {
        if (glType === 5126) internalFormat = 34836
        if (glType === 5131) internalFormat = 34842
        if (glType === 5121) internalFormat = 32856
      }

      if (internalFormat === 33325 || internalFormat === 33326 || internalFormat === 34842 || internalFormat === 34836) {
        extensions.get('EXT_color_buffer_float')
      }

      return internalFormat
    } // Fallback filters for non-power-of-2 textures

    function filterFallback(f) {
      if (f === NearestFilter || f === NearestMipmapNearestFilter || f === NearestMipmapLinearFilter) {
        return 9728
      }

      return 9729
    } //

    function onTextureDispose(event) {
      var texture = event.target
      texture.removeEventListener('dispose', onTextureDispose)
      deallocateTexture(texture)

      if (texture.isVideoTexture) {
        _videoTextures.delete(texture)
      }

      info.memory.textures--
    }

    function onRenderTargetDispose(event) {
      var renderTarget = event.target
      renderTarget.removeEventListener('dispose', onRenderTargetDispose)
      deallocateRenderTarget(renderTarget)
      info.memory.textures--
    } //

    function deallocateTexture(texture) {
      var textureProperties = properties.get(texture)
      if (textureProperties.__webglInit === undefined) return

      _gl.deleteTexture(textureProperties.__webglTexture)

      properties.remove(texture)
    }

    function deallocateRenderTarget(renderTarget) {
      var renderTargetProperties = properties.get(renderTarget)
      var textureProperties = properties.get(renderTarget.texture)
      if (!renderTarget) return

      if (textureProperties.__webglTexture !== undefined) {
        _gl.deleteTexture(textureProperties.__webglTexture)
      }

      if (renderTarget.depthTexture) {
        renderTarget.depthTexture.dispose()
      }

      if (renderTarget.isWebGLCubeRenderTarget) {
        for (var i = 0; i < 6; i++) {
          _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer[i])

          if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer[i])
        }
      } else {
        _gl.deleteFramebuffer(renderTargetProperties.__webglFramebuffer)

        if (renderTargetProperties.__webglDepthbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthbuffer)
        if (renderTargetProperties.__webglMultisampledFramebuffer) _gl.deleteFramebuffer(renderTargetProperties.__webglMultisampledFramebuffer)
        if (renderTargetProperties.__webglColorRenderbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglColorRenderbuffer)
        if (renderTargetProperties.__webglDepthRenderbuffer) _gl.deleteRenderbuffer(renderTargetProperties.__webglDepthRenderbuffer)
      }

      properties.remove(renderTarget.texture)
      properties.remove(renderTarget)
    } //

    var textureUnits = 0

    function resetTextureUnits() {
      textureUnits = 0
    }

    function allocateTextureUnit() {
      var textureUnit = textureUnits

      if (textureUnit >= maxTextures) {
        console.warn('THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + maxTextures)
      }

      textureUnits += 1
      return textureUnit
    } //

    function setTexture2D(texture, slot) {
      var textureProperties = properties.get(texture)
      if (texture.isVideoTexture) updateVideoTexture(texture)

      if (texture.version > 0 && textureProperties.__version !== texture.version) {
        var image = texture.image

        if (image === undefined) {
          console.warn('THREE.WebGLRenderer: Texture marked for update but image is undefined')
        } else if (image.complete === false) {
          console.warn('THREE.WebGLRenderer: Texture marked for update but image is incomplete')
        } else {
          uploadTexture(textureProperties, texture, slot)
          return
        }
      }

      state.activeTexture(33984 + slot)
      state.bindTexture(3553, textureProperties.__webglTexture)
    }

    function setTexture2DArray(texture, slot) {
      var textureProperties = properties.get(texture)

      if (texture.version > 0 && textureProperties.__version !== texture.version) {
        uploadTexture(textureProperties, texture, slot)
        return
      }

      state.activeTexture(33984 + slot)
      state.bindTexture(35866, textureProperties.__webglTexture)
    }

    function setTexture3D(texture, slot) {
      var textureProperties = properties.get(texture)

      if (texture.version > 0 && textureProperties.__version !== texture.version) {
        uploadTexture(textureProperties, texture, slot)
        return
      }

      state.activeTexture(33984 + slot)
      state.bindTexture(32879, textureProperties.__webglTexture)
    }

    function setTextureCube(texture, slot) {
      var textureProperties = properties.get(texture)

      if (texture.version > 0 && textureProperties.__version !== texture.version) {
        uploadCubeTexture(textureProperties, texture, slot)
        return
      }

      state.activeTexture(33984 + slot)
      state.bindTexture(34067, textureProperties.__webglTexture)
    }

    var wrappingToGL =
      ((_wrappingToGL = {}),
      (_wrappingToGL[RepeatWrapping] = 10497),
      (_wrappingToGL[ClampToEdgeWrapping] = 33071),
      (_wrappingToGL[MirroredRepeatWrapping] = 33648),
      _wrappingToGL)
    var filterToGL =
      ((_filterToGL = {}),
      (_filterToGL[NearestFilter] = 9728),
      (_filterToGL[NearestMipmapNearestFilter] = 9984),
      (_filterToGL[NearestMipmapLinearFilter] = 9986),
      (_filterToGL[LinearFilter] = 9729),
      (_filterToGL[LinearMipmapNearestFilter] = 9985),
      (_filterToGL[LinearMipmapLinearFilter] = 9987),
      _filterToGL)

    function setTextureParameters(textureType, texture, supportsMips) {
      if (supportsMips) {
        _gl.texParameteri(textureType, 10242, wrappingToGL[texture.wrapS])

        _gl.texParameteri(textureType, 10243, wrappingToGL[texture.wrapT])

        if (textureType === 32879 || textureType === 35866) {
          _gl.texParameteri(textureType, 32882, wrappingToGL[texture.wrapR])
        }

        _gl.texParameteri(textureType, 10240, filterToGL[texture.magFilter])

        _gl.texParameteri(textureType, 10241, filterToGL[texture.minFilter])
      } else {
        _gl.texParameteri(textureType, 10242, 33071)

        _gl.texParameteri(textureType, 10243, 33071)

        if (textureType === 32879 || textureType === 35866) {
          _gl.texParameteri(textureType, 32882, 33071)
        }

        if (texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping) {
          console.warn('THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.')
        }

        _gl.texParameteri(textureType, 10240, filterFallback(texture.magFilter))

        _gl.texParameteri(textureType, 10241, filterFallback(texture.minFilter))

        if (texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter) {
          console.warn('THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.')
        }
      }

      var extension = extensions.get('EXT_texture_filter_anisotropic')

      if (extension) {
        if (texture.type === FloatType && extensions.get('OES_texture_float_linear') === null) return
        if (texture.type === HalfFloatType && (isWebGL2 || extensions.get('OES_texture_half_float_linear')) === null) return

        if (texture.anisotropy > 1 || properties.get(texture).__currentAnisotropy) {
          _gl.texParameterf(textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(texture.anisotropy, capabilities.getMaxAnisotropy()))

          properties.get(texture).__currentAnisotropy = texture.anisotropy
        }
      }
    }

    function initTexture(textureProperties, texture) {
      if (textureProperties.__webglInit === undefined) {
        textureProperties.__webglInit = true
        texture.addEventListener('dispose', onTextureDispose)
        textureProperties.__webglTexture = _gl.createTexture()
        info.memory.textures++
      }
    }

    function uploadTexture(textureProperties, texture, slot) {
      var textureType = 3553
      if (texture.isDataTexture2DArray) textureType = 35866
      if (texture.isDataTexture3D) textureType = 32879
      initTexture(textureProperties, texture)
      state.activeTexture(33984 + slot)
      state.bindTexture(textureType, textureProperties.__webglTexture)

      _gl.pixelStorei(37440, texture.flipY)

      _gl.pixelStorei(37441, texture.premultiplyAlpha)

      _gl.pixelStorei(3317, texture.unpackAlignment)

      var needsPowerOfTwo = textureNeedsPowerOfTwo(texture) && isPowerOfTwo(texture.image) === false
      var image = resizeImage(texture.image, needsPowerOfTwo, false, maxTextureSize)
      var supportsMips = isPowerOfTwo(image) || isWebGL2,
        glFormat = utils.convert(texture.format)
      var glType = utils.convert(texture.type),
        glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType)
      setTextureParameters(textureType, texture, supportsMips)
      var mipmap
      var mipmaps = texture.mipmaps

      if (texture.isDepthTexture) {
        // populate depth texture with dummy data
        glInternalFormat = 6402

        if (isWebGL2) {
          if (texture.type === FloatType) {
            glInternalFormat = 36012
          } else if (texture.type === UnsignedIntType) {
            glInternalFormat = 33190
          } else if (texture.type === UnsignedInt248Type) {
            glInternalFormat = 35056
          } else {
            glInternalFormat = 33189 // WebGL2 requires sized internalformat for glTexImage2D
          }
        } else {
          if (texture.type === FloatType) {
            console.error('WebGLRenderer: Floating point depth texture requires WebGL2.')
          }
        } // validation checks for WebGL 1

        if (texture.format === DepthFormat && glInternalFormat === 6402) {
          // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
          // DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT
          // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
          if (texture.type !== UnsignedShortType && texture.type !== UnsignedIntType) {
            console.warn('THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.')
            texture.type = UnsignedShortType
            glType = utils.convert(texture.type)
          }
        }

        if (texture.format === DepthStencilFormat && glInternalFormat === 6402) {
          // Depth stencil textures need the DEPTH_STENCIL internal format
          // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
          glInternalFormat = 34041 // The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
          // DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.
          // (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)

          if (texture.type !== UnsignedInt248Type) {
            console.warn('THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.')
            texture.type = UnsignedInt248Type
            glType = utils.convert(texture.type)
          }
        } //

        state.texImage2D(3553, 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 && supportsMips) {
          for (var i = 0, il = mipmaps.length; i < il; i++) {
            mipmap = mipmaps[i]
            state.texImage2D(3553, i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data)
          }

          texture.generateMipmaps = false
          textureProperties.__maxMipLevel = mipmaps.length - 1
        } else {
          state.texImage2D(3553, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, image.data)
          textureProperties.__maxMipLevel = 0
        }
      } else if (texture.isCompressedTexture) {
        for (var _i = 0, _il = mipmaps.length; _i < _il; _i++) {
          mipmap = mipmaps[_i]

          if (texture.format !== RGBAFormat && texture.format !== RGBFormat) {
            if (glFormat !== null) {
              state.compressedTexImage2D(3553, _i, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data)
            } else {
              console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()')
            }
          } else {
            state.texImage2D(3553, _i, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data)
          }
        }

        textureProperties.__maxMipLevel = mipmaps.length - 1
      } else if (texture.isDataTexture2DArray) {
        state.texImage3D(35866, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data)
        textureProperties.__maxMipLevel = 0
      } else if (texture.isDataTexture3D) {
        state.texImage3D(32879, 0, glInternalFormat, image.width, image.height, image.depth, 0, glFormat, glType, image.data)
        textureProperties.__maxMipLevel = 0
      } 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 && supportsMips) {
          for (var _i2 = 0, _il2 = mipmaps.length; _i2 < _il2; _i2++) {
            mipmap = mipmaps[_i2]
            state.texImage2D(3553, _i2, glInternalFormat, glFormat, glType, mipmap)
          }

          texture.generateMipmaps = false
          textureProperties.__maxMipLevel = mipmaps.length - 1
        } else {
          state.texImage2D(3553, 0, glInternalFormat, glFormat, glType, image)
          textureProperties.__maxMipLevel = 0
        }
      }

      if (textureNeedsGenerateMipmaps(texture, supportsMips)) {
        generateMipmap(textureType, texture, image.width, image.height)
      }

      textureProperties.__version = texture.version
      if (texture.onUpdate) texture.onUpdate(texture)
    }

    function uploadCubeTexture(textureProperties, texture, slot) {
      if (texture.image.length !== 6) return
      initTexture(textureProperties, texture)
      state.activeTexture(33984 + slot)
      state.bindTexture(34067, textureProperties.__webglTexture)

      _gl.pixelStorei(37440, texture.flipY)

      var isCompressed = texture && (texture.isCompressedTexture || texture.image[0].isCompressedTexture)
      var isDataTexture = texture.image[0] && texture.image[0].isDataTexture
      var cubeImage = []

      for (var i = 0; i < 6; i++) {
        if (!isCompressed && !isDataTexture) {
          cubeImage[i] = resizeImage(texture.image[i], false, true, maxCubemapSize)
        } else {
          cubeImage[i] = isDataTexture ? texture.image[i].image : texture.image[i]
        }
      }

      var image = cubeImage[0],
        supportsMips = isPowerOfTwo(image) || isWebGL2,
        glFormat = utils.convert(texture.format),
        glType = utils.convert(texture.type),
        glInternalFormat = getInternalFormat(texture.internalFormat, glFormat, glType)
      setTextureParameters(34067, texture, supportsMips)
      var mipmaps

      if (isCompressed) {
        for (var _i3 = 0; _i3 < 6; _i3++) {
          mipmaps = cubeImage[_i3].mipmaps

          for (var j = 0; j < mipmaps.length; j++) {
            var mipmap = mipmaps[j]

            if (texture.format !== RGBAFormat && texture.format !== RGBFormat) {
              if (glFormat !== null) {
                state.compressedTexImage2D(34069 + _i3, j, glInternalFormat, mipmap.width, mipmap.height, 0, mipmap.data)
              } else {
                console.warn('THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()')
              }
            } else {
              state.texImage2D(34069 + _i3, j, glInternalFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data)
            }
          }
        }

        textureProperties.__maxMipLevel = mipmaps.length - 1
      } else {
        mipmaps = texture.mipmaps

        for (var _i4 = 0; _i4 < 6; _i4++) {
          if (isDataTexture) {
            state.texImage2D(34069 + _i4, 0, glInternalFormat, cubeImage[_i4].width, cubeImage[_i4].height, 0, glFormat, glType, cubeImage[_i4].data)

            for (var _j = 0; _j < mipmaps.length; _j++) {
              var _mipmap = mipmaps[_j]
              var mipmapImage = _mipmap.image[_i4].image
              state.texImage2D(34069 + _i4, _j + 1, glInternalFormat, mipmapImage.width, mipmapImage.height, 0, glFormat, glType, mipmapImage.data)
            }
          } else {
            state.texImage2D(34069 + _i4, 0, glInternalFormat, glFormat, glType, cubeImage[_i4])

            for (var _j2 = 0; _j2 < mipmaps.length; _j2++) {
              var _mipmap2 = mipmaps[_j2]
              state.texImage2D(34069 + _i4, _j2 + 1, glInternalFormat, glFormat, glType, _mipmap2.image[_i4])
            }
          }
        }

        textureProperties.__maxMipLevel = mipmaps.length
      }

      if (textureNeedsGenerateMipmaps(texture, supportsMips)) {
        // We assume images for cube map have the same size.
        generateMipmap(34067, texture, image.width, image.height)
      }

      textureProperties.__version = texture.version
      if (texture.onUpdate) texture.onUpdate(texture)
    } // Render targets
    // Setup storage for target texture and bind it to correct framebuffer

    function setupFrameBufferTexture(framebuffer, renderTarget, attachment, textureTarget) {
      var glFormat = utils.convert(renderTarget.texture.format)
      var glType = utils.convert(renderTarget.texture.type)
      var glInternalFormat = getInternalFormat(renderTarget.texture.internalFormat, glFormat, glType)
      state.texImage2D(textureTarget, 0, glInternalFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null)

      _gl.bindFramebuffer(36160, framebuffer)

      _gl.framebufferTexture2D(36160, attachment, textureTarget, properties.get(renderTarget.texture).__webglTexture, 0)

      _gl.bindFramebuffer(36160, null)
    } // Setup storage for internal depth/stencil buffers and bind to correct framebuffer

    function setupRenderBufferStorage(renderbuffer, renderTarget, isMultisample) {
      _gl.bindRenderbuffer(36161, renderbuffer)

      if (renderTarget.depthBuffer && !renderTarget.stencilBuffer) {
        var glInternalFormat = 33189

        if (isMultisample) {
          var depthTexture = renderTarget.depthTexture

          if (depthTexture && depthTexture.isDepthTexture) {
            if (depthTexture.type === FloatType) {
              glInternalFormat = 36012
            } else if (depthTexture.type === UnsignedIntType) {
              glInternalFormat = 33190
            }
          }

          var samples = getRenderTargetSamples(renderTarget)

          _gl.renderbufferStorageMultisample(36161, samples, glInternalFormat, renderTarget.width, renderTarget.height)
        } else {
          _gl.renderbufferStorage(36161, glInternalFormat, renderTarget.width, renderTarget.height)
        }

        _gl.framebufferRenderbuffer(36160, 36096, 36161, renderbuffer)
      } else if (renderTarget.depthBuffer && renderTarget.stencilBuffer) {
        if (isMultisample) {
          var _samples = getRenderTargetSamples(renderTarget)

          _gl.renderbufferStorageMultisample(36161, _samples, 35056, renderTarget.width, renderTarget.height)
        } else {
          _gl.renderbufferStorage(36161, 34041, renderTarget.width, renderTarget.height)
        }

        _gl.framebufferRenderbuffer(36160, 33306, 36161, renderbuffer)
      } else {
        var glFormat = utils.convert(renderTarget.texture.format)
        var glType = utils.convert(renderTarget.texture.type)

        var _glInternalFormat = getInternalFormat(renderTarget.texture.internalFormat, glFormat, glType)

        if (isMultisample) {
          var _samples2 = getRenderTargetSamples(renderTarget)

          _gl.renderbufferStorageMultisample(36161, _samples2, _glInternalFormat, renderTarget.width, renderTarget.height)
        } else {
          _gl.renderbufferStorage(36161, _glInternalFormat, renderTarget.width, renderTarget.height)
        }
      }

      _gl.bindRenderbuffer(36161, null)
    } // Setup resources for a Depth Texture for a FBO (needs an extension)

    function setupDepthTexture(framebuffer, renderTarget) {
      var isCube = renderTarget && renderTarget.isWebGLCubeRenderTarget
      if (isCube) throw new Error('Depth Texture with cube render targets is not supported')

      _gl.bindFramebuffer(36160, framebuffer)

      if (!(renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture)) {
        throw new Error('renderTarget.depthTexture must be an instance of THREE.DepthTexture')
      } // upload an empty depth texture with framebuffer size

      if (
        !properties.get(renderTarget.depthTexture).__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)

      var webglDepthTexture = properties.get(renderTarget.depthTexture).__webglTexture

      if (renderTarget.depthTexture.format === DepthFormat) {
        _gl.framebufferTexture2D(36160, 36096, 3553, webglDepthTexture, 0)
      } else if (renderTarget.depthTexture.format === DepthStencilFormat) {
        _gl.framebufferTexture2D(36160, 33306, 3553, webglDepthTexture, 0)
      } else {
        throw new Error('Unknown depthTexture format')
      }
    } // Setup GL resources for a non-texture depth buffer

    function setupDepthRenderbuffer(renderTarget) {
      var renderTargetProperties = properties.get(renderTarget)
      var isCube = renderTarget.isWebGLCubeRenderTarget === true

      if (renderTarget.depthTexture) {
        if (isCube) throw new Error('target.depthTexture not supported in Cube render targets')
        setupDepthTexture(renderTargetProperties.__webglFramebuffer, renderTarget)
      } else {
        if (isCube) {
          renderTargetProperties.__webglDepthbuffer = []

          for (var i = 0; i < 6; i++) {
            _gl.bindFramebuffer(36160, renderTargetProperties.__webglFramebuffer[i])

            renderTargetProperties.__webglDepthbuffer[i] = _gl.createRenderbuffer()
            setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer[i], renderTarget, false)
          }
        } else {
          _gl.bindFramebuffer(36160, renderTargetProperties.__webglFramebuffer)

          renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer()
          setupRenderBufferStorage(renderTargetProperties.__webglDepthbuffer, renderTarget, false)
        }
      }

      _gl.bindFramebuffer(36160, null)
    } // Set up GL resources for the render target

    function setupRenderTarget(renderTarget) {
      var renderTargetProperties = properties.get(renderTarget)
      var textureProperties = properties.get(renderTarget.texture)
      renderTarget.addEventListener('dispose', onRenderTargetDispose)
      textureProperties.__webglTexture = _gl.createTexture()
      info.memory.textures++
      var isCube = renderTarget.isWebGLCubeRenderTarget === true
      var isMultisample = renderTarget.isWebGLMultisampleRenderTarget === true
      var supportsMips = isPowerOfTwo(renderTarget) || isWebGL2 // Handles WebGL2 RGBFormat fallback - #18858

      if (isWebGL2 && renderTarget.texture.format === RGBFormat && (renderTarget.texture.type === FloatType || renderTarget.texture.type === HalfFloatType)) {
        renderTarget.texture.format = RGBAFormat
        console.warn('THREE.WebGLRenderer: Rendering to textures with RGB format is not supported. Using RGBA format instead.')
      } // Setup framebuffer

      if (isCube) {
        renderTargetProperties.__webglFramebuffer = []

        for (var i = 0; i < 6; i++) {
          renderTargetProperties.__webglFramebuffer[i] = _gl.createFramebuffer()
        }
      } else {
        renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer()

        if (isMultisample) {
          if (isWebGL2) {
            renderTargetProperties.__webglMultisampledFramebuffer = _gl.createFramebuffer()
            renderTargetProperties.__webglColorRenderbuffer = _gl.createRenderbuffer()

            _gl.bindRenderbuffer(36161, renderTargetProperties.__webglColorRenderbuffer)

            var glFormat = utils.convert(renderTarget.texture.format)
            var glType = utils.convert(renderTarget.texture.type)
            var glInternalFormat = getInternalFormat(renderTarget.texture.internalFormat, glFormat, glType)
            var samples = getRenderTargetSamples(renderTarget)

            _gl.renderbufferStorageMultisample(36161, samples, glInternalFormat, renderTarget.width, renderTarget.height)

            _gl.bindFramebuffer(36160, renderTargetProperties.__webglMultisampledFramebuffer)

            _gl.framebufferRenderbuffer(36160, 36064, 36161, renderTargetProperties.__webglColorRenderbuffer)

            _gl.bindRenderbuffer(36161, null)

            if (renderTarget.depthBuffer) {
              renderTargetProperties.__webglDepthRenderbuffer = _gl.createRenderbuffer()
              setupRenderBufferStorage(renderTargetProperties.__webglDepthRenderbuffer, renderTarget, true)
            }

            _gl.bindFramebuffer(36160, null)
          } else {
            console.warn('THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.')
          }
        }
      } // Setup color buffer

      if (isCube) {
        state.bindTexture(34067, textureProperties.__webglTexture)
        setTextureParameters(34067, renderTarget.texture, supportsMips)

        for (var _i5 = 0; _i5 < 6; _i5++) {
          setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer[_i5], renderTarget, 36064, 34069 + _i5)
        }

        if (textureNeedsGenerateMipmaps(renderTarget.texture, supportsMips)) {
          generateMipmap(34067, renderTarget.texture, renderTarget.width, renderTarget.height)
        }

        state.bindTexture(34067, null)
      } else {
        state.bindTexture(3553, textureProperties.__webglTexture)
        setTextureParameters(3553, renderTarget.texture, supportsMips)
        setupFrameBufferTexture(renderTargetProperties.__webglFramebuffer, renderTarget, 36064, 3553)

        if (textureNeedsGenerateMipmaps(renderTarget.texture, supportsMips)) {
          generateMipmap(3553, renderTarget.texture, renderTarget.width, renderTarget.height)
        }

        state.bindTexture(3553, null)
      } // Setup depth and stencil buffers

      if (renderTarget.depthBuffer) {
        setupDepthRenderbuffer(renderTarget)
      }
    }

    function updateRenderTargetMipmap(renderTarget) {
      var texture = renderTarget.texture
      var supportsMips = isPowerOfTwo(renderTarget) || isWebGL2

      if (textureNeedsGenerateMipmaps(texture, supportsMips)) {
        var target = renderTarget.isWebGLCubeRenderTarget ? 34067 : 3553

        var webglTexture = properties.get(texture).__webglTexture

        state.bindTexture(target, webglTexture)
        generateMipmap(target, texture, renderTarget.width, renderTarget.height)
        state.bindTexture(target, null)
      }
    }

    function updateMultisampleRenderTarget(renderTarget) {
      if (renderTarget.isWebGLMultisampleRenderTarget) {
        if (isWebGL2) {
          var renderTargetProperties = properties.get(renderTarget)

          _gl.bindFramebuffer(36008, renderTargetProperties.__webglMultisampledFramebuffer)

          _gl.bindFramebuffer(36009, renderTargetProperties.__webglFramebuffer)

          var width = renderTarget.width
          var height = renderTarget.height
          var mask = 16384
          if (renderTarget.depthBuffer) mask |= 256
          if (renderTarget.stencilBuffer) mask |= 1024

          _gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, mask, 9728)

          _gl.bindFramebuffer(36160, renderTargetProperties.__webglMultisampledFramebuffer) // see #18905
        } else {
          console.warn('THREE.WebGLRenderer: WebGLMultisampleRenderTarget can only be used with WebGL2.')
        }
      }
    }

    function getRenderTargetSamples(renderTarget) {
      return isWebGL2 && renderTarget.isWebGLMultisampleRenderTarget ? Math.min(maxSamples, renderTarget.samples) : 0
    }

    function updateVideoTexture(texture) {
      var frame = info.render.frame // Check the last frame we updated the VideoTexture

      if (_videoTextures.get(texture) !== frame) {
        _videoTextures.set(texture, frame)

        texture.update()
      }
    } // backwards compatibility

    var warnedTexture2D = false
    var warnedTextureCube = false

    function safeSetTexture2D(texture, slot) {
      if (texture && texture.isWebGLRenderTarget) {
        if (warnedTexture2D === false) {
          console.warn("THREE.WebGLTextures.safeSetTexture2D: don't use render targets as textures. Use their .texture property instead.")
          warnedTexture2D = true
        }

        texture = texture.texture
      }

      setTexture2D(texture, slot)
    }

    function safeSetTextureCube(texture, slot) {
      if (texture && texture.isWebGLCubeRenderTarget) {
        if (warnedTextureCube === false) {
          console.warn("THREE.WebGLTextures.safeSetTextureCube: don't use cube render targets as textures. Use their .texture property instead.")
          warnedTextureCube = true
        }

        texture = texture.texture
      }

      setTextureCube(texture, slot)
    } //

    this.allocateTextureUnit = allocateTextureUnit
    this.resetTextureUnits = resetTextureUnits
    this.setTexture2D = setTexture2D
    this.setTexture2DArray = setTexture2DArray
    this.setTexture3D = setTexture3D
    this.setTextureCube = setTextureCube
    this.setupRenderTarget = setupRenderTarget
    this.updateRenderTargetMipmap = updateRenderTargetMipmap
    this.updateMultisampleRenderTarget = updateMultisampleRenderTarget
    this.safeSetTexture2D = safeSetTexture2D
    this.safeSetTextureCube = safeSetTextureCube
  }

  function WebGLUtils(gl, extensions, capabilities) {
    var isWebGL2 = capabilities.isWebGL2

    function convert(p) {
      var extension
      if (p === UnsignedByteType) return 5121
      if (p === UnsignedShort4444Type) return 32819
      if (p === UnsignedShort5551Type) return 32820
      if (p === UnsignedShort565Type) return 33635
      if (p === ByteType) return 5120
      if (p === ShortType) return 5122
      if (p === UnsignedShortType) return 5123
      if (p === IntType) return 5124
      if (p === UnsignedIntType) return 5125
      if (p === FloatType) return 5126

      if (p === HalfFloatType) {
        if (isWebGL2) return 5131
        extension = extensions.get('OES_texture_half_float')

        if (extension !== null) {
          return extension.HALF_FLOAT_OES
        } else {
          return null
        }
      }

      if (p === AlphaFormat) return 6406
      if (p === RGBFormat) return 6407
      if (p === RGBAFormat) return 6408
      if (p === LuminanceFormat) return 6409
      if (p === LuminanceAlphaFormat) return 6410
      if (p === DepthFormat) return 6402
      if (p === DepthStencilFormat) return 34041
      if (p === RedFormat) return 6403 // WebGL2 formats.

      if (p === RedIntegerFormat) return 36244
      if (p === RGFormat) return 33319
      if (p === RGIntegerFormat) return 33320
      if (p === RGBIntegerFormat) return 36248
      if (p === RGBAIntegerFormat) return 36249

      if (p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format || p === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format) {
        extension = extensions.get('WEBGL_compressed_texture_s3tc')

        if (extension !== null) {
          if (p === RGB_S3TC_DXT1_Format) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT
          if (p === RGBA_S3TC_DXT1_Format) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT
          if (p === RGBA_S3TC_DXT3_Format) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT
          if (p === RGBA_S3TC_DXT5_Format) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT
        } else {
          return null
        }
      }

      if (p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format || p === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format) {
        extension = extensions.get('WEBGL_compressed_texture_pvrtc')

        if (extension !== null) {
          if (p === RGB_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
          if (p === RGB_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG
          if (p === RGBA_PVRTC_4BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
          if (p === RGBA_PVRTC_2BPPV1_Format) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG
        } else {
          return null
        }
      }

      if (p === RGB_ETC1_Format) {
        extension = extensions.get('WEBGL_compressed_texture_etc1')

        if (extension !== null) {
          return extension.COMPRESSED_RGB_ETC1_WEBGL
        } else {
          return null
        }
      }

      if (p === RGB_ETC2_Format || p === RGBA_ETC2_EAC_Format) {
        extension = extensions.get('WEBGL_compressed_texture_etc')

        if (extension !== null) {
          if (p === RGB_ETC2_Format) return extension.COMPRESSED_RGB8_ETC2
          if (p === RGBA_ETC2_EAC_Format) return extension.COMPRESSED_RGBA8_ETC2_EAC
        }
      }

      if (
        p === RGBA_ASTC_4x4_Format ||
        p === RGBA_ASTC_5x4_Format ||
        p === RGBA_ASTC_5x5_Format ||
        p === RGBA_ASTC_6x5_Format ||
        p === RGBA_ASTC_6x6_Format ||
        p === RGBA_ASTC_8x5_Format ||
        p === RGBA_ASTC_8x6_Format ||
        p === RGBA_ASTC_8x8_Format ||
        p === RGBA_ASTC_10x5_Format ||
        p === RGBA_ASTC_10x6_Format ||
        p === RGBA_ASTC_10x8_Format ||
        p === RGBA_ASTC_10x10_Format ||
        p === RGBA_ASTC_12x10_Format ||
        p === RGBA_ASTC_12x12_Format ||
        p === SRGB8_ALPHA8_ASTC_4x4_Format ||
        p === SRGB8_ALPHA8_ASTC_5x4_Format ||
        p === SRGB8_ALPHA8_ASTC_5x5_Format ||
        p === SRGB8_ALPHA8_ASTC_6x5_Format ||
        p === SRGB8_ALPHA8_ASTC_6x6_Format ||
        p === SRGB8_ALPHA8_ASTC_8x5_Format ||
        p === SRGB8_ALPHA8_ASTC_8x6_Format ||
        p === SRGB8_ALPHA8_ASTC_8x8_Format ||
        p === SRGB8_ALPHA8_ASTC_10x5_Format ||
        p === SRGB8_ALPHA8_ASTC_10x6_Format ||
        p === SRGB8_ALPHA8_ASTC_10x8_Format ||
        p === SRGB8_ALPHA8_ASTC_10x10_Format ||
        p === SRGB8_ALPHA8_ASTC_12x10_Format ||
        p === SRGB8_ALPHA8_ASTC_12x12_Format
      ) {
        extension = extensions.get('WEBGL_compressed_texture_astc')

        if (extension !== null) {
          // TODO Complete?
          return p
        } else {
          return null
        }
      }

      if (p === RGBA_BPTC_Format) {
        extension = extensions.get('EXT_texture_compression_bptc')

        if (extension !== null) {
          // TODO Complete?
          return p
        } else {
          return null
        }
      }

      if (p === UnsignedInt248Type) {
        if (isWebGL2) return 34042
        extension = extensions.get('WEBGL_depth_texture')

        if (extension !== null) {
          return extension.UNSIGNED_INT_24_8_WEBGL
        } else {
          return null
        }
      }
    }

    return {
      convert: convert
    }
  }

  function ArrayCamera(array) {
    if (array === void 0) {
      array = []
    }

    PerspectiveCamera.call(this)
    this.cameras = array
  }

  ArrayCamera.prototype = Object.assign(Object.create(PerspectiveCamera.prototype), {
    constructor: ArrayCamera,
    isArrayCamera: true
  })

  function Group() {
    Object3D.call(this)
    this.type = 'Group'
  }

  Group.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Group,
    isGroup: true
  })

  function WebXRController() {
    this._targetRay = null
    this._grip = null
    this._hand = null
  }

  Object.assign(WebXRController.prototype, {
    constructor: WebXRController,
    getHandSpace: function getHandSpace() {
      if (this._hand === null) {
        this._hand = new Group()
        this._hand.matrixAutoUpdate = false
        this._hand.visible = false
        this._hand.joints = []
        this._hand.inputState = {
          pinching: false
        }

        if (window.XRHand) {
          for (var i = 0; i <= window.XRHand.LITTLE_PHALANX_TIP; i++) {
            // The transform of this joint will be updated with the joint pose on each frame
            var joint = new Group()
            joint.matrixAutoUpdate = false
            joint.visible = false

            this._hand.joints.push(joint) // ??

            this._hand.add(joint)
          }
        }
      }

      return this._hand
    },
    getTargetRaySpace: function getTargetRaySpace() {
      if (this._targetRay === null) {
        this._targetRay = new Group()
        this._targetRay.matrixAutoUpdate = false
        this._targetRay.visible = false
      }

      return this._targetRay
    },
    getGripSpace: function getGripSpace() {
      if (this._grip === null) {
        this._grip = new Group()
        this._grip.matrixAutoUpdate = false
        this._grip.visible = false
      }

      return this._grip
    },
    dispatchEvent: function 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
    },
    disconnect: function 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: function update(inputSource, frame, referenceSpace) {
      var inputPose = null
      var gripPose = null
      var handPose = null
      var targetRay = this._targetRay
      var grip = this._grip
      var hand = this._hand

      if (inputSource && frame.session.visibilityState !== 'visible-blurred') {
        if (hand && inputSource.hand) {
          handPose = true

          for (var i = 0; i <= window.XRHand.LITTLE_PHALANX_TIP; i++) {
            if (inputSource.hand[i]) {
              // Update the joints groups with the XRJoint poses
              var jointPose = frame.getJointPose(inputSource.hand[i], referenceSpace)
              var joint = hand.joints[i]

              if (jointPose !== null) {
                joint.matrix.fromArray(jointPose.transform.matrix)
                joint.matrix.decompose(joint.position, joint.rotation, joint.scale)
                joint.jointRadius = jointPose.radius
              }

              joint.visible = jointPose !== null // Custom events
              // Check pinch

              var indexTip = hand.joints[window.XRHand.INDEX_PHALANX_TIP]
              var thumbTip = hand.joints[window.XRHand.THUMB_PHALANX_TIP]
              var distance = indexTip.position.distanceTo(thumbTip.position)
              var distanceToPinch = 0.02
              var 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 (targetRay !== null) {
            inputPose = frame.getPose(inputSource.targetRaySpace, referenceSpace)

            if (inputPose !== null) {
              targetRay.matrix.fromArray(inputPose.transform.matrix)
              targetRay.matrix.decompose(targetRay.position, targetRay.rotation, targetRay.scale)
            }
          }

          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)
            }
          }
        }
      }

      if (targetRay !== null) {
        targetRay.visible = inputPose !== null
      }

      if (grip !== null) {
        grip.visible = gripPose !== null
      }

      if (hand !== null) {
        hand.visible = handPose !== null
      }

      return this
    }
  })

  function WebXRManager(renderer, gl) {
    var scope = this
    var session = null
    var framebufferScaleFactor = 1.0
    var referenceSpace = null
    var referenceSpaceType = 'local-floor'
    var pose = null
    var controllers = []
    var inputSourcesMap = new Map() //

    var cameraL = new PerspectiveCamera()
    cameraL.layers.enable(1)
    cameraL.viewport = new Vector4()
    var cameraR = new PerspectiveCamera()
    cameraR.layers.enable(2)
    cameraR.viewport = new Vector4()
    var cameras = [cameraL, cameraR]
    var cameraVR = new ArrayCamera()
    cameraVR.layers.enable(1)
    cameraVR.layers.enable(2)
    var _currentDepthNear = null
    var _currentDepthFar = null //

    this.enabled = false
    this.isPresenting = false

    this.getController = function (index) {
      var controller = controllers[index]

      if (controller === undefined) {
        controller = new WebXRController()
        controllers[index] = controller
      }

      return controller.getTargetRaySpace()
    }

    this.getControllerGrip = function (index) {
      var controller = controllers[index]

      if (controller === undefined) {
        controller = new WebXRController()
        controllers[index] = controller
      }

      return controller.getGripSpace()
    }

    this.getHand = function (index) {
      var controller = controllers[index]

      if (controller === undefined) {
        controller = new WebXRController()
        controllers[index] = controller
      }

      return controller.getHandSpace()
    } //

    function onSessionEvent(event) {
      var controller = inputSourcesMap.get(event.inputSource)

      if (controller) {
        controller.dispatchEvent({
          type: event.type,
          data: event.inputSource
        })
      }
    }

    function onSessionEnd() {
      inputSourcesMap.forEach(function (controller, inputSource) {
        controller.disconnect(inputSource)
      })
      inputSourcesMap.clear() //

      renderer.setFramebuffer(null)
      renderer.setRenderTarget(renderer.getRenderTarget()) // Hack #15830

      animation.stop()
      scope.isPresenting = false
      scope.dispatchEvent({
        type: 'sessionend'
      })
    }

    function onRequestReferenceSpace(value) {
      referenceSpace = value
      animation.setContext(session)
      animation.start()
      scope.isPresenting = true
      scope.dispatchEvent({
        type: 'sessionstart'
      })
    }

    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 referenceSpace
    }

    this.getSession = function () {
      return session
    }

    this.setSession = function (value) {
      session = value

      if (session !== null) {
        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)
        var attributes = gl.getContextAttributes()

        if (attributes.xrCompatible !== true) {
          gl.makeXRCompatible()
        }

        var layerInit = {
          antialias: attributes.antialias,
          alpha: attributes.alpha,
          depth: attributes.depth,
          stencil: attributes.stencil,
          framebufferScaleFactor: framebufferScaleFactor
        } // eslint-disable-next-line no-undef

        var baseLayer = new XRWebGLLayer(session, gl, layerInit)
        session.updateRenderState({
          baseLayer: baseLayer
        })
        session.requestReferenceSpace(referenceSpaceType).then(onRequestReferenceSpace) //

        session.addEventListener('inputsourceschange', updateInputSources)
      }
    }

    function updateInputSources(event) {
      var inputSources = session.inputSources // Assign inputSources to available controllers

      for (var i = 0; i < controllers.length; i++) {
        inputSourcesMap.set(inputSources[i], controllers[i])
      } // Notify disconnected

      for (var _i = 0; _i < event.removed.length; _i++) {
        var inputSource = event.removed[_i]
        var controller = inputSourcesMap.get(inputSource)

        if (controller) {
          controller.dispatchEvent({
            type: 'disconnected',
            data: inputSource
          })
          inputSourcesMap.delete(inputSource)
        }
      } // Notify connected

      for (var _i2 = 0; _i2 < event.added.length; _i2++) {
        var _inputSource = event.added[_i2]

        var _controller = inputSourcesMap.get(_inputSource)

        if (_controller) {
          _controller.dispatchEvent({
            type: 'connected',
            data: _inputSource
          })
        }
      }
    } //

    var cameraLPos = new Vector3()
    var cameraRPos = new Vector3()
    /**
     * 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
     */

    function setProjectionFromUnion(camera, cameraL, cameraR) {
      cameraLPos.setFromMatrixPosition(cameraL.matrixWorld)
      cameraRPos.setFromMatrixPosition(cameraR.matrixWorld)
      var ipd = cameraLPos.distanceTo(cameraRPos)
      var projL = cameraL.projectionMatrix.elements
      var 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.

      var near = projL[14] / (projL[10] - 1)
      var far = projL[14] / (projL[10] + 1)
      var topFov = (projL[9] + 1) / projL[5]
      var bottomFov = (projL[9] - 1) / projL[5]
      var leftFov = (projL[8] - 1) / projL[0]
      var rightFov = (projR[8] + 1) / projR[0]
      var left = near * leftFov
      var right = near * rightFov // Calculate the new camera's position offset from the
      // left camera. xOffset should be roughly half `ipd`.

      var zOffset = ipd / (-leftFov + rightFov)
      var 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() // 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.

      var near2 = near + zOffset
      var far2 = far + zOffset
      var left2 = left - xOffset
      var right2 = right + (ipd - xOffset)
      var top2 = ((topFov * far) / far2) * near2
      var bottom2 = ((bottomFov * far) / far2) * near2
      camera.projectionMatrix.makePerspective(left2, right2, top2, bottom2, near2, far2)
    }

    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.getCamera = function (camera) {
      cameraVR.near = cameraR.near = cameraL.near = camera.near
      cameraVR.far = cameraR.far = cameraL.far = camera.far

      if (_currentDepthNear !== cameraVR.near || _currentDepthFar !== cameraVR.far) {
        // Note that the new renderState won't apply until the next frame. See #18320
        session.updateRenderState({
          depthNear: cameraVR.near,
          depthFar: cameraVR.far
        })
        _currentDepthNear = cameraVR.near
        _currentDepthFar = cameraVR.far
      }

      var parent = camera.parent
      var cameras = cameraVR.cameras
      updateCamera(cameraVR, parent)

      for (var i = 0; i < cameras.length; i++) {
        updateCamera(cameras[i], parent)
      } // update camera and its children

      camera.matrixWorld.copy(cameraVR.matrixWorld)
      var children = camera.children

      for (var _i3 = 0, l = children.length; _i3 < l; _i3++) {
        children[_i3].updateMatrixWorld(true)
      } // update projection matrix for proper view frustum culling

      if (cameras.length === 2) {
        setProjectionFromUnion(cameraVR, cameraL, cameraR)
      } else {
        // assume single camera setup (AR)
        cameraVR.projectionMatrix.copy(cameraL.projectionMatrix)
      }

      return cameraVR
    } // Animation Loop

    var onAnimationFrameCallback = null

    function onAnimationFrame(time, frame) {
      pose = frame.getViewerPose(referenceSpace)

      if (pose !== null) {
        var views = pose.views
        var baseLayer = session.renderState.baseLayer
        renderer.setFramebuffer(baseLayer.framebuffer)
        var cameraVRNeedsUpdate = false // check if it's necessary to rebuild cameraVR's camera list

        if (views.length !== cameraVR.cameras.length) {
          cameraVR.cameras.length = 0
          cameraVRNeedsUpdate = true
        }

        for (var i = 0; i < views.length; i++) {
          var view = views[i]
          var viewport = baseLayer.getViewport(view)
          var camera = cameras[i]
          camera.matrix.fromArray(view.transform.matrix)
          camera.projectionMatrix.fromArray(view.projectionMatrix)
          camera.viewport.set(viewport.x, viewport.y, viewport.width, viewport.height)

          if (i === 0) {
            cameraVR.matrix.copy(camera.matrix)
          }

          if (cameraVRNeedsUpdate === true) {
            cameraVR.cameras.push(camera)
          }
        }
      } //

      var inputSources = session.inputSources

      for (var _i4 = 0; _i4 < controllers.length; _i4++) {
        var controller = controllers[_i4]
        var inputSource = inputSources[_i4]
        controller.update(inputSource, frame, referenceSpace)
      }

      if (onAnimationFrameCallback) onAnimationFrameCallback(time, frame)
    }

    var animation = new WebGLAnimation()
    animation.setAnimationLoop(onAnimationFrame)

    this.setAnimationLoop = function (callback) {
      onAnimationFrameCallback = callback
    }

    this.dispose = function () {}
  }

  Object.assign(WebXRManager.prototype, EventDispatcher.prototype)

  function WebGLMaterials(properties) {
    function refreshFogUniforms(uniforms, fog) {
      uniforms.fogColor.value.copy(fog.color)

      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) {
      if (material.isMeshBasicMaterial) {
        refreshUniformsCommon(uniforms, material)
      } else if (material.isMeshLambertMaterial) {
        refreshUniformsCommon(uniforms, material)
        refreshUniformsLambert(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)

        if (material.isMeshPhysicalMaterial) {
          refreshUniformsPhysical(uniforms, material)
        } else {
          refreshUniformsStandard(uniforms, material)
        }
      } else if (material.isMeshMatcapMaterial) {
        refreshUniformsCommon(uniforms, material)
        refreshUniformsMatcap(uniforms, material)
      } else if (material.isMeshDepthMaterial) {
        refreshUniformsCommon(uniforms, material)
        refreshUniformsDepth(uniforms, material)
      } else if (material.isMeshDistanceMaterial) {
        refreshUniformsCommon(uniforms, material)
        refreshUniformsDistance(uniforms, material)
      } else if (material.isMeshNormalMaterial) {
        refreshUniformsCommon(uniforms, material)
        refreshUniformsNormal(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
      }

      if (material.alphaMap) {
        uniforms.alphaMap.value = material.alphaMap
      }

      if (material.specularMap) {
        uniforms.specularMap.value = material.specularMap
      }

      var envMap = properties.get(material).envMap

      if (envMap) {
        uniforms.envMap.value = envMap
        uniforms.flipEnvMap.value = envMap.isCubeTexture && envMap._needsFlipEnvMap ? -1 : 1
        uniforms.reflectivity.value = material.reflectivity
        uniforms.refractionRatio.value = material.refractionRatio

        var maxMipLevel = properties.get(envMap).__maxMipLevel

        if (maxMipLevel !== undefined) {
          uniforms.maxMipLevel.value = maxMipLevel
        }
      }

      if (material.lightMap) {
        uniforms.lightMap.value = material.lightMap
        uniforms.lightMapIntensity.value = material.lightMapIntensity
      }

      if (material.aoMap) {
        uniforms.aoMap.value = material.aoMap
        uniforms.aoMapIntensity.value = material.aoMapIntensity
      } // uv repeat and offset setting priorities
      // 1. color map
      // 2. specular map
      // 3. displacementMap map
      // 4. normal map
      // 5. bump map
      // 6. roughnessMap map
      // 7. metalnessMap map
      // 8. alphaMap map
      // 9. emissiveMap map
      // 10. clearcoat map
      // 11. clearcoat normal map
      // 12. clearcoat roughnessMap map

      var uvScaleMap

      if (material.map) {
        uvScaleMap = material.map
      } else if (material.specularMap) {
        uvScaleMap = material.specularMap
      } else if (material.displacementMap) {
        uvScaleMap = material.displacementMap
      } else if (material.normalMap) {
        uvScaleMap = material.normalMap
      } else if (material.bumpMap) {
        uvScaleMap = material.bumpMap
      } else if (material.roughnessMap) {
        uvScaleMap = material.roughnessMap
      } else if (material.metalnessMap) {
        uvScaleMap = material.metalnessMap
      } else if (material.alphaMap) {
        uvScaleMap = material.alphaMap
      } else if (material.emissiveMap) {
        uvScaleMap = material.emissiveMap
      } else if (material.clearcoatMap) {
        uvScaleMap = material.clearcoatMap
      } else if (material.clearcoatNormalMap) {
        uvScaleMap = material.clearcoatNormalMap
      } else if (material.clearcoatRoughnessMap) {
        uvScaleMap = material.clearcoatRoughnessMap
      }

      if (uvScaleMap !== undefined) {
        // backwards compatibility
        if (uvScaleMap.isWebGLRenderTarget) {
          uvScaleMap = uvScaleMap.texture
        }

        if (uvScaleMap.matrixAutoUpdate === true) {
          uvScaleMap.updateMatrix()
        }

        uniforms.uvTransform.value.copy(uvScaleMap.matrix)
      } // uv repeat and offset setting priorities for uv2
      // 1. ao map
      // 2. light map

      var uv2ScaleMap

      if (material.aoMap) {
        uv2ScaleMap = material.aoMap
      } else if (material.lightMap) {
        uv2ScaleMap = material.lightMap
      }

      if (uv2ScaleMap !== undefined) {
        // backwards compatibility
        if (uv2ScaleMap.isWebGLRenderTarget) {
          uv2ScaleMap = uv2ScaleMap.texture
        }

        if (uv2ScaleMap.matrixAutoUpdate === true) {
          uv2ScaleMap.updateMatrix()
        }

        uniforms.uv2Transform.value.copy(uv2ScaleMap.matrix)
      }
    }

    function refreshUniformsLine(uniforms, material) {
      uniforms.diffuse.value.copy(material.color)
      uniforms.opacity.value = material.opacity
    }

    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
      }

      if (material.alphaMap) {
        uniforms.alphaMap.value = material.alphaMap
      } // uv repeat and offset setting priorities
      // 1. color map
      // 2. alpha map

      var uvScaleMap

      if (material.map) {
        uvScaleMap = material.map
      } else if (material.alphaMap) {
        uvScaleMap = material.alphaMap
      }

      if (uvScaleMap !== undefined) {
        if (uvScaleMap.matrixAutoUpdate === true) {
          uvScaleMap.updateMatrix()
        }

        uniforms.uvTransform.value.copy(uvScaleMap.matrix)
      }
    }

    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
      }

      if (material.alphaMap) {
        uniforms.alphaMap.value = material.alphaMap
      } // uv repeat and offset setting priorities
      // 1. color map
      // 2. alpha map

      var uvScaleMap

      if (material.map) {
        uvScaleMap = material.map
      } else if (material.alphaMap) {
        uvScaleMap = material.alphaMap
      }

      if (uvScaleMap !== undefined) {
        if (uvScaleMap.matrixAutoUpdate === true) {
          uvScaleMap.updateMatrix()
        }

        uniforms.uvTransform.value.copy(uvScaleMap.matrix)
      }
    }

    function refreshUniformsLambert(uniforms, material) {
      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }
    }

    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 )

      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }

      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
        if (material.side === BackSide) uniforms.bumpScale.value *= -1
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
        if (material.side === BackSide) uniforms.normalScale.value.negate()
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    function refreshUniformsToon(uniforms, material) {
      if (material.gradientMap) {
        uniforms.gradientMap.value = material.gradientMap
      }

      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }

      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
        if (material.side === BackSide) uniforms.bumpScale.value *= -1
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
        if (material.side === BackSide) uniforms.normalScale.value.negate()
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    function refreshUniformsStandard(uniforms, material) {
      uniforms.roughness.value = material.roughness
      uniforms.metalness.value = material.metalness

      if (material.roughnessMap) {
        uniforms.roughnessMap.value = material.roughnessMap
      }

      if (material.metalnessMap) {
        uniforms.metalnessMap.value = material.metalnessMap
      }

      if (material.emissiveMap) {
        uniforms.emissiveMap.value = material.emissiveMap
      }

      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
        if (material.side === BackSide) uniforms.bumpScale.value *= -1
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
        if (material.side === BackSide) uniforms.normalScale.value.negate()
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }

      var envMap = properties.get(material).envMap

      if (envMap) {
        //uniforms.envMap.value = material.envMap; // part of uniforms common
        uniforms.envMapIntensity.value = material.envMapIntensity
      }
    }

    function refreshUniformsPhysical(uniforms, material) {
      refreshUniformsStandard(uniforms, material)
      uniforms.reflectivity.value = material.reflectivity // also part of uniforms common

      uniforms.clearcoat.value = material.clearcoat
      uniforms.clearcoatRoughness.value = material.clearcoatRoughness
      if (material.sheen) uniforms.sheen.value.copy(material.sheen)

      if (material.clearcoatMap) {
        uniforms.clearcoatMap.value = material.clearcoatMap
      }

      if (material.clearcoatRoughnessMap) {
        uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap
      }

      if (material.clearcoatNormalMap) {
        uniforms.clearcoatNormalScale.value.copy(material.clearcoatNormalScale)
        uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap

        if (material.side === BackSide) {
          uniforms.clearcoatNormalScale.value.negate()
        }
      }

      uniforms.transmission.value = material.transmission

      if (material.transmissionMap) {
        uniforms.transmissionMap.value = material.transmissionMap
      }
    }

    function refreshUniformsMatcap(uniforms, material) {
      if (material.matcap) {
        uniforms.matcap.value = material.matcap
      }

      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
        if (material.side === BackSide) uniforms.bumpScale.value *= -1
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
        if (material.side === BackSide) uniforms.normalScale.value.negate()
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    function refreshUniformsDepth(uniforms, material) {
      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    function refreshUniformsDistance(uniforms, material) {
      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }

      uniforms.referencePosition.value.copy(material.referencePosition)
      uniforms.nearDistance.value = material.nearDistance
      uniforms.farDistance.value = material.farDistance
    }

    function refreshUniformsNormal(uniforms, material) {
      if (material.bumpMap) {
        uniforms.bumpMap.value = material.bumpMap
        uniforms.bumpScale.value = material.bumpScale
        if (material.side === BackSide) uniforms.bumpScale.value *= -1
      }

      if (material.normalMap) {
        uniforms.normalMap.value = material.normalMap
        uniforms.normalScale.value.copy(material.normalScale)
        if (material.side === BackSide) uniforms.normalScale.value.negate()
      }

      if (material.displacementMap) {
        uniforms.displacementMap.value = material.displacementMap
        uniforms.displacementScale.value = material.displacementScale
        uniforms.displacementBias.value = material.displacementBias
      }
    }

    return {
      refreshFogUniforms: refreshFogUniforms,
      refreshMaterialUniforms: refreshMaterialUniforms
    }
  }

  function createCanvasElement() {
    var canvas = document.createElementNS('http://www.w3.org/1999/xhtml', 'canvas')
    canvas.style.display = 'block'
    return canvas
  }

  function WebGLRenderer(parameters) {
    parameters = parameters || {}

    var _canvas = parameters.canvas !== undefined ? parameters.canvas : createCanvasElement(),
      _context = parameters.context !== undefined ? parameters.context : null,
      _alpha = parameters.alpha !== undefined ? parameters.alpha : false,
      _depth = parameters.depth !== undefined ? parameters.depth : true,
      _stencil = parameters.stencil !== undefined ? parameters.stencil : true,
      _antialias = parameters.antialias !== undefined ? parameters.antialias : false,
      _premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,
      _preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false,
      _powerPreference = parameters.powerPreference !== undefined ? parameters.powerPreference : 'default',
      _failIfMajorPerformanceCaveat = parameters.failIfMajorPerformanceCaveat !== undefined ? parameters.failIfMajorPerformanceCaveat : false

    var currentRenderList = null
    var 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 state isolated from the parent render call.

    var 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
    } // 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.gammaFactor = 2.0 // for backwards compatibility

    this.outputEncoding = LinearEncoding // physical lights

    this.physicallyCorrectLights = false // tone mapping

    this.toneMapping = NoToneMapping
    this.toneMappingExposure = 1.0 // morphs

    this.maxMorphTargets = 8
    this.maxMorphNormals = 4 // internal properties

    var _this = this

    var _isContextLost = false // internal state cache

    var _framebuffer = null
    var _currentActiveCubeFace = 0
    var _currentActiveMipmapLevel = 0
    var _currentRenderTarget = null
    var _currentFramebuffer = null

    var _currentMaterialId = -1

    var _currentCamera = null

    var _currentViewport = new Vector4()

    var _currentScissor = new Vector4()

    var _currentScissorTest = null //

    var _width = _canvas.width
    var _height = _canvas.height
    var _pixelRatio = 1
    var _opaqueSort = null
    var _transparentSort = null

    var _viewport = new Vector4(0, 0, _width, _height)

    var _scissor = new Vector4(0, 0, _width, _height)

    var _scissorTest = false // frustum

    var _frustum = new Frustum() // clipping

    var _clippingEnabled = false
    var _localClippingEnabled = false // camera matrices cache

    var _projScreenMatrix = new Matrix4()

    var _vector3 = new Vector3()

    var _emptyScene = {
      background: null,
      fog: null,
      environment: null,
      overrideMaterial: null,
      isScene: true
    }

    function getTargetPixelRatio() {
      return _currentRenderTarget === null ? _pixelRatio : 1
    } // initialize

    var _gl = _context

    function getContext(contextNames, contextAttributes) {
      for (var i = 0; i < contextNames.length; i++) {
        var contextName = contextNames[i]

        var context = _canvas.getContext(contextName, contextAttributes)

        if (context !== null) return context
      }

      return null
    }

    try {
      var contextAttributes = {
        alpha: _alpha,
        depth: _depth,
        stencil: _stencil,
        antialias: _antialias,
        premultipliedAlpha: _premultipliedAlpha,
        preserveDrawingBuffer: _preserveDrawingBuffer,
        powerPreference: _powerPreference,
        failIfMajorPerformanceCaveat: _failIfMajorPerformanceCaveat
      } // event listeners must be registered before WebGL context is created, see #12753

      _canvas.addEventListener('webglcontextlost', onContextLost, false)

      _canvas.addEventListener('webglcontextrestored', onContextRestore, false)

      if (_gl === null) {
        var contextNames = ['webgl2', 'webgl', 'experimental-webgl']

        if (_this.isWebGL1Renderer === true) {
          contextNames.shift()
        }

        _gl = getContext(contextNames, contextAttributes)

        if (_gl === null) {
          if (getContext(contextNames)) {
            throw new Error('Error creating WebGL context with your selected attributes.')
          } else {
            throw new Error('Error creating WebGL context.')
          }
        }
      } // Some experimental-webgl implementations do not have getShaderPrecisionFormat

      if (_gl.getShaderPrecisionFormat === undefined) {
        _gl.getShaderPrecisionFormat = function () {
          return {
            rangeMin: 1,
            rangeMax: 1,
            precision: 1
          }
        }
      }
    } catch (error) {
      console.error('THREE.WebGLRenderer: ' + error.message)
      throw error
    }

    var extensions, capabilities, state, info
    var properties, textures, cubemaps, attributes, geometries, objects
    var programCache, materials, renderLists, renderStates, clipping
    var background, morphtargets, bufferRenderer, indexedBufferRenderer
    var utils, bindingStates

    function initGLContext() {
      extensions = new WebGLExtensions(_gl)
      capabilities = new WebGLCapabilities(_gl, extensions, parameters)

      if (capabilities.isWebGL2 === false) {
        extensions.get('WEBGL_depth_texture')
        extensions.get('OES_texture_float')
        extensions.get('OES_texture_half_float')
        extensions.get('OES_texture_half_float_linear')
        extensions.get('OES_standard_derivatives')
        extensions.get('OES_element_index_uint')
        extensions.get('OES_vertex_array_object')
        extensions.get('ANGLE_instanced_arrays')
      }

      extensions.get('OES_texture_float_linear')
      utils = new WebGLUtils(_gl, extensions, capabilities)
      state = new WebGLState(_gl, extensions, capabilities)
      state.scissor(_currentScissor.copy(_scissor).multiplyScalar(_pixelRatio).floor())
      state.viewport(_currentViewport.copy(_viewport).multiplyScalar(_pixelRatio).floor())
      info = new WebGLInfo(_gl)
      properties = new WebGLProperties()
      textures = new WebGLTextures(_gl, extensions, state, properties, capabilities, utils, info)
      cubemaps = new WebGLCubeMaps(_this)
      attributes = new WebGLAttributes(_gl, capabilities)
      bindingStates = new WebGLBindingStates(_gl, extensions, attributes, capabilities)
      geometries = new WebGLGeometries(_gl, attributes, info, bindingStates)
      objects = new WebGLObjects(_gl, geometries, attributes, info)
      morphtargets = new WebGLMorphtargets(_gl)
      clipping = new WebGLClipping(properties)
      programCache = new WebGLPrograms(_this, cubemaps, extensions, capabilities, bindingStates, clipping)
      materials = new WebGLMaterials(properties)
      renderLists = new WebGLRenderLists(properties)
      renderStates = new WebGLRenderStates(extensions, capabilities)
      background = new WebGLBackground(_this, cubemaps, state, objects, _premultipliedAlpha)
      bufferRenderer = new WebGLBufferRenderer(_gl, extensions, info, capabilities)
      indexedBufferRenderer = new WebGLIndexedBufferRenderer(_gl, extensions, info, capabilities)
      info.programs = programCache.programs
      _this.capabilities = capabilities
      _this.extensions = extensions
      _this.properties = properties
      _this.renderLists = renderLists
      _this.state = state
      _this.info = info
    }

    initGLContext() // xr

    var xr = new WebXRManager(_this, _gl)
    this.xr = xr // shadow map

    var shadowMap = new WebGLShadowMap(_this, objects, capabilities.maxTextureSize)
    this.shadowMap = shadowMap // API

    this.getContext = function () {
      return _gl
    }

    this.getContextAttributes = function () {
      return _gl.getContextAttributes()
    }

    this.forceContextLoss = function () {
      var extension = extensions.get('WEBGL_lose_context')
      if (extension) extension.loseContext()
    }

    this.forceContextRestore = function () {
      var 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) {
      if (target === undefined) {
        console.warn('WebGLRenderer: .getsize() now requires a Vector2 as an argument')
        target = new Vector2()
      }

      return target.set(_width, _height)
    }

    this.setSize = function (width, height, updateStyle) {
      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 !== false) {
        _canvas.style.width = width + 'px'
        _canvas.style.height = height + 'px'
      }

      this.setViewport(0, 0, width, height)
    }

    this.getDrawingBufferSize = function (target) {
      if (target === undefined) {
        console.warn('WebGLRenderer: .getdrawingBufferSize() now requires a Vector2 as an argument')
        target = new Vector2()
      }

      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) {
      if (target === undefined) {
        console.warn('WebGLRenderer: .getCurrentViewport() now requires a Vector4 as an argument')
        target = new Vector4()
      }

      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).floor())
    }

    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).floor())
    }

    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) {
      if (target === undefined) {
        console.warn('WebGLRenderer: .getClearColor() now requires a Color as an argument')
        target = new Color()
      }

      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, depth, stencil) {
      var bits = 0
      if (color === undefined || color) bits |= 16384
      if (depth === undefined || depth) bits |= 256
      if (stencil === undefined || stencil) bits |= 1024

      _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)

      renderLists.dispose()
      renderStates.dispose()
      properties.dispose()
      cubemaps.dispose()
      objects.dispose()
      bindingStates.dispose()
      xr.dispose()
      animation.stop()
    } // Events

    function onContextLost(event) {
      event.preventDefault()
      console.log('THREE.WebGLRenderer: Context Lost.')
      _isContextLost = true
    }

    function onContextRestore() {
      /* event */
      console.log('THREE.WebGLRenderer: Context Restored.')
      _isContextLost = false
      initGLContext()
    }

    function onMaterialDispose(event) {
      var material = event.target
      material.removeEventListener('dispose', onMaterialDispose)
      deallocateMaterial(material)
    } // Buffer deallocation

    function deallocateMaterial(material) {
      releaseMaterialProgramReference(material)
      properties.remove(material)
    }

    function releaseMaterialProgramReference(material) {
      var programInfo = properties.get(material).program

      if (programInfo !== undefined) {
        programCache.releaseProgram(programInfo)
      }
    } // Buffer rendering

    function renderObjectImmediate(object, program) {
      object.render(function (object) {
        _this.renderBufferImmediate(object, program)
      })
    }

    this.renderBufferImmediate = function (object, program) {
      bindingStates.initAttributes()
      var buffers = properties.get(object)
      if (object.hasPositions && !buffers.position) buffers.position = _gl.createBuffer()
      if (object.hasNormals && !buffers.normal) buffers.normal = _gl.createBuffer()
      if (object.hasUvs && !buffers.uv) buffers.uv = _gl.createBuffer()
      if (object.hasColors && !buffers.color) buffers.color = _gl.createBuffer()
      var programAttributes = program.getAttributes()

      if (object.hasPositions) {
        _gl.bindBuffer(34962, buffers.position)

        _gl.bufferData(34962, object.positionArray, 35048)

        bindingStates.enableAttribute(programAttributes.position)

        _gl.vertexAttribPointer(programAttributes.position, 3, 5126, false, 0, 0)
      }

      if (object.hasNormals) {
        _gl.bindBuffer(34962, buffers.normal)

        _gl.bufferData(34962, object.normalArray, 35048)

        bindingStates.enableAttribute(programAttributes.normal)

        _gl.vertexAttribPointer(programAttributes.normal, 3, 5126, false, 0, 0)
      }

      if (object.hasUvs) {
        _gl.bindBuffer(34962, buffers.uv)

        _gl.bufferData(34962, object.uvArray, 35048)

        bindingStates.enableAttribute(programAttributes.uv)

        _gl.vertexAttribPointer(programAttributes.uv, 2, 5126, false, 0, 0)
      }

      if (object.hasColors) {
        _gl.bindBuffer(34962, buffers.color)

        _gl.bufferData(34962, object.colorArray, 35048)

        bindingStates.enableAttribute(programAttributes.color)

        _gl.vertexAttribPointer(programAttributes.color, 3, 5126, false, 0, 0)
      }

      bindingStates.disableUnusedAttributes()

      _gl.drawArrays(4, 0, object.count)

      object.count = 0
    }

    this.renderBufferDirect = function (camera, scene, geometry, material, object, group) {
      if (scene === null) scene = _emptyScene // renderBufferDirect second parameter used to be fog (could be null)

      var frontFaceCW = object.isMesh && object.matrixWorld.determinant() < 0
      var program = setProgram(camera, scene, material, object)
      state.setMaterial(material, frontFaceCW) //

      var index = geometry.index
      var position = geometry.attributes.position //

      if (index === null) {
        if (position === undefined || position.count === 0) return
      } else if (index.count === 0) {
        return
      } //

      var rangeFactor = 1

      if (material.wireframe === true) {
        index = geometries.getWireframeAttribute(geometry)
        rangeFactor = 2
      }

      if (material.morphTargets || material.morphNormals) {
        morphtargets.update(object, geometry, material, program)
      }

      bindingStates.setup(object, material, program, geometry, index)
      var attribute
      var renderer = bufferRenderer

      if (index !== null) {
        attribute = attributes.get(index)
        renderer = indexedBufferRenderer
        renderer.setIndex(attribute)
      } //

      var dataCount = index !== null ? index.count : position.count
      var rangeStart = geometry.drawRange.start * rangeFactor
      var rangeCount = geometry.drawRange.count * rangeFactor
      var groupStart = group !== null ? group.start * rangeFactor : 0
      var groupCount = group !== null ? group.count * rangeFactor : Infinity
      var drawStart = Math.max(rangeStart, groupStart)
      var drawEnd = Math.min(dataCount, rangeStart + rangeCount, groupStart + groupCount) - 1
      var drawCount = Math.max(0, drawEnd - drawStart + 1)
      if (drawCount === 0) return //

      if (object.isMesh) {
        if (material.wireframe === true) {
          state.setLineWidth(material.wireframeLinewidth * getTargetPixelRatio())
          renderer.setMode(1)
        } else {
          renderer.setMode(4)
        }
      } else if (object.isLine) {
        var lineWidth = material.linewidth
        if (lineWidth === undefined) lineWidth = 1 // Not using Line*Material

        state.setLineWidth(lineWidth * getTargetPixelRatio())

        if (object.isLineSegments) {
          renderer.setMode(1)
        } else if (object.isLineLoop) {
          renderer.setMode(2)
        } else {
          renderer.setMode(3)
        }
      } else if (object.isPoints) {
        renderer.setMode(0)
      } else if (object.isSprite) {
        renderer.setMode(4)
      }

      if (object.isInstancedMesh) {
        renderer.renderInstances(drawStart, drawCount, object.count)
      } else if (geometry.isInstancedBufferGeometry) {
        var instanceCount = Math.min(geometry.instanceCount, geometry._maxInstanceCount)
        renderer.renderInstances(drawStart, drawCount, instanceCount)
      } else {
        renderer.render(drawStart, drawCount)
      }
    } // Compile

    this.compile = function (scene, camera) {
      currentRenderState = renderStates.get(scene)
      currentRenderState.init()
      scene.traverseVisible(function (object) {
        if (object.isLight && object.layers.test(camera.layers)) {
          currentRenderState.pushLight(object)

          if (object.castShadow) {
            currentRenderState.pushShadow(object)
          }
        }
      })
      currentRenderState.setupLights()
      var compiled = new WeakMap()
      scene.traverse(function (object) {
        var material = object.material

        if (material) {
          if (Array.isArray(material)) {
            for (var i = 0; i < material.length; i++) {
              var material2 = material[i]

              if (compiled.has(material2) === false) {
                initMaterial(material2, scene, object)
                compiled.set(material2)
              }
            }
          } else if (compiled.has(material) === false) {
            initMaterial(material, scene, object)
            compiled.set(material)
          }
        }
      })
    } // Animation Loop

    var onAnimationFrameCallback = null

    function onAnimationFrame(time) {
      if (xr.isPresenting) return
      if (onAnimationFrameCallback) onAnimationFrameCallback(time)
    }

    var animation = new WebGLAnimation()
    animation.setAnimationLoop(onAnimationFrame)
    if (typeof window !== 'undefined') animation.setContext(window)

    this.setAnimationLoop = function (callback) {
      onAnimationFrameCallback = callback
      xr.setAnimationLoop(callback)
      callback === null ? animation.stop() : animation.start()
    } // Rendering

    this.render = function (scene, camera) {
      var renderTarget, forceClear

      if (arguments[2] !== undefined) {
        console.warn('THREE.WebGLRenderer.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.')
        renderTarget = arguments[2]
      }

      if (arguments[3] !== undefined) {
        console.warn('THREE.WebGLRenderer.render(): the forceClear argument has been removed. Use .clear() instead.')
        forceClear = arguments[3]
      }

      if (camera !== undefined && camera.isCamera !== true) {
        console.error('THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.')
        return
      }

      if (_isContextLost === true) return // reset caching for this frame

      bindingStates.resetDefaultState()
      _currentMaterialId = -1
      _currentCamera = null // update scene graph

      if (scene.autoUpdate === true) scene.updateMatrixWorld() // update camera matrices and frustum

      if (camera.parent === null) camera.updateMatrixWorld()

      if (xr.enabled === true && xr.isPresenting === true) {
        camera = xr.getCamera(camera)
      } //

      if (scene.isScene === true) scene.onBeforeRender(_this, scene, camera, renderTarget || _currentRenderTarget)
      currentRenderState = renderStates.get(scene, renderStateStack.length)
      currentRenderState.init()
      renderStateStack.push(currentRenderState)

      _projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)

      _frustum.setFromProjectionMatrix(_projScreenMatrix)

      _localClippingEnabled = this.localClippingEnabled
      _clippingEnabled = clipping.init(this.clippingPlanes, _localClippingEnabled, camera)
      currentRenderList = renderLists.get(scene, camera)
      currentRenderList.init()
      projectObject(scene, camera, 0, _this.sortObjects)
      currentRenderList.finish()

      if (_this.sortObjects === true) {
        currentRenderList.sort(_opaqueSort, _transparentSort)
      } //

      if (_clippingEnabled === true) clipping.beginShadows()
      var shadowsArray = currentRenderState.state.shadowsArray
      shadowMap.render(shadowsArray, scene, camera)
      currentRenderState.setupLights()
      currentRenderState.setupLightsView(camera)
      if (_clippingEnabled === true) clipping.endShadows() //

      if (this.info.autoReset === true) this.info.reset()

      if (renderTarget !== undefined) {
        this.setRenderTarget(renderTarget)
      } //

      background.render(currentRenderList, scene, camera, forceClear) // render scene

      var opaqueObjects = currentRenderList.opaque
      var transparentObjects = currentRenderList.transparent
      if (opaqueObjects.length > 0) renderObjects(opaqueObjects, scene, camera)
      if (transparentObjects.length > 0) renderObjects(transparentObjects, scene, camera) //

      if (scene.isScene === true) scene.onAfterRender(_this, scene, camera) //

      if (_currentRenderTarget !== null) {
        // Generate mipmap if we're using any kind of mipmap filtering
        textures.updateRenderTargetMipmap(_currentRenderTarget) // resolve multisample renderbuffers to a single-sample texture if necessary

        textures.updateMultisampleRenderTarget(_currentRenderTarget)
      } // 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) // _gl.finish();

      renderStateStack.pop()

      if (renderStateStack.length > 0) {
        currentRenderState = renderStateStack[renderStateStack.length - 1]
      } else {
        currentRenderState = null
      }

      currentRenderList = null
    }

    function projectObject(object, camera, groupOrder, sortObjects) {
      if (object.visible === false) return
      var 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) {
              _vector3.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix)
            }

            var geometry = objects.update(object)
            var material = object.material

            if (material.visible) {
              currentRenderList.push(object, geometry, material, groupOrder, _vector3.z, null)
            }
          }
        } else if (object.isImmediateRenderObject) {
          if (sortObjects) {
            _vector3.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix)
          }

          currentRenderList.push(object, null, object.material, groupOrder, _vector3.z, null)
        } else if (object.isMesh || object.isLine || object.isPoints) {
          if (object.isSkinnedMesh) {
            // update skeleton only once in a frame
            if (object.skeleton.frame !== info.render.frame) {
              object.skeleton.update()
              object.skeleton.frame = info.render.frame
            }
          }

          if (!object.frustumCulled || _frustum.intersectsObject(object)) {
            if (sortObjects) {
              _vector3.setFromMatrixPosition(object.matrixWorld).applyMatrix4(_projScreenMatrix)
            }

            var _geometry = objects.update(object)

            var _material = object.material

            if (Array.isArray(_material)) {
              var groups = _geometry.groups

              for (var i = 0, l = groups.length; i < l; i++) {
                var group = groups[i]
                var groupMaterial = _material[group.materialIndex]

                if (groupMaterial && groupMaterial.visible) {
                  currentRenderList.push(object, _geometry, groupMaterial, groupOrder, _vector3.z, group)
                }
              }
            } else if (_material.visible) {
              currentRenderList.push(object, _geometry, _material, groupOrder, _vector3.z, null)
            }
          }
        }
      }

      var children = object.children

      for (var _i = 0, _l = children.length; _i < _l; _i++) {
        projectObject(children[_i], camera, groupOrder, sortObjects)
      }
    }

    function renderObjects(renderList, scene, camera) {
      var overrideMaterial = scene.isScene === true ? scene.overrideMaterial : null

      for (var i = 0, l = renderList.length; i < l; i++) {
        var renderItem = renderList[i]
        var object = renderItem.object
        var geometry = renderItem.geometry
        var material = overrideMaterial === null ? renderItem.material : overrideMaterial
        var group = renderItem.group

        if (camera.isArrayCamera) {
          var cameras = camera.cameras

          for (var j = 0, jl = cameras.length; j < jl; j++) {
            var camera2 = cameras[j]

            if (object.layers.test(camera2.layers)) {
              state.viewport(_currentViewport.copy(camera2.viewport))
              currentRenderState.setupLightsView(camera2)
              renderObject(object, scene, camera2, geometry, material, group)
            }
          }
        } else {
          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)

      if (object.isImmediateRenderObject) {
        var program = setProgram(camera, scene, material, object)
        state.setMaterial(material)
        bindingStates.reset()
        renderObjectImmediate(object, program)
      } else {
        _this.renderBufferDirect(camera, scene, geometry, material, object, group)
      }

      object.onAfterRender(_this, scene, camera, geometry, material, group)
    }

    function initMaterial(material, scene, object) {
      if (scene.isScene !== true) scene = _emptyScene // scene could be a Mesh, Line, Points, ...

      var materialProperties = properties.get(material)
      var lights = currentRenderState.state.lights
      var shadowsArray = currentRenderState.state.shadowsArray
      var lightsStateVersion = lights.state.version
      var parameters = programCache.getParameters(material, lights.state, shadowsArray, scene, object)
      var programCacheKey = programCache.getProgramCacheKey(parameters)
      var program = materialProperties.program
      var programChange = true

      if (program === undefined) {
        // new material
        material.addEventListener('dispose', onMaterialDispose)
      } else if (program.cacheKey !== programCacheKey) {
        // changed glsl or parameters
        releaseMaterialProgramReference(material)
      } else if (materialProperties.lightsStateVersion !== lightsStateVersion) {
        programChange = false
      } else if (parameters.shaderID !== undefined) {
        // same glsl and uniform list, envMap still needs the update here to avoid a frame-late effect
        var environment = material.isMeshStandardMaterial ? scene.environment : null
        materialProperties.envMap = cubemaps.get(material.envMap || environment)
        return
      } else {
        // only rebuild uniform list
        programChange = false
      }

      if (programChange) {
        parameters.uniforms = programCache.getUniforms(material)
        material.onBeforeCompile(parameters, _this)
        program = programCache.acquireProgram(parameters, programCacheKey)
        materialProperties.program = program
        materialProperties.uniforms = parameters.uniforms
        materialProperties.outputEncoding = parameters.outputEncoding
      }

      var uniforms = materialProperties.uniforms

      if ((!material.isShaderMaterial && !material.isRawShaderMaterial) || material.clipping === true) {
        materialProperties.numClippingPlanes = clipping.numPlanes
        materialProperties.numIntersection = clipping.numIntersection
        uniforms.clippingPlanes = clipping.uniform
      }

      materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null
      materialProperties.fog = scene.fog
      materialProperties.envMap = cubemaps.get(material.envMap || materialProperties.environment) // 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.spotShadowMatrix.value = lights.state.spotShadowMatrix
        uniforms.pointShadowMap.value = lights.state.pointShadowMap
        uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix // TODO (abelnation): add area lights shadow info to uniforms
      }

      var progUniforms = materialProperties.program.getUniforms()
      var uniformsList = WebGLUniforms.seqWithValue(progUniforms.seq, uniforms)
      materialProperties.uniformsList = uniformsList
    }

    function setProgram(camera, scene, material, object) {
      if (scene.isScene !== true) scene = _emptyScene // scene could be a Mesh, Line, Points, ...

      textures.resetTextureUnits()
      var fog = scene.fog
      var environment = material.isMeshStandardMaterial ? scene.environment : null
      var encoding = _currentRenderTarget === null ? _this.outputEncoding : _currentRenderTarget.texture.encoding
      var envMap = cubemaps.get(material.envMap || environment)
      var materialProperties = properties.get(material)
      var lights = currentRenderState.state.lights

      if (_clippingEnabled === true) {
        if (_localClippingEnabled === true || camera !== _currentCamera) {
          var 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)
        }
      }

      if (material.version === materialProperties.__version) {
        if (material.fog && materialProperties.fog !== fog) {
          initMaterial(material, scene, object)
        } else if (materialProperties.environment !== environment) {
          initMaterial(material, scene, object)
        } else if (materialProperties.needsLights && materialProperties.lightsStateVersion !== lights.state.version) {
          initMaterial(material, scene, object)
        } else if (
          materialProperties.numClippingPlanes !== undefined &&
          (materialProperties.numClippingPlanes !== clipping.numPlanes || materialProperties.numIntersection !== clipping.numIntersection)
        ) {
          initMaterial(material, scene, object)
        } else if (materialProperties.outputEncoding !== encoding) {
          initMaterial(material, scene, object)
        } else if (materialProperties.envMap !== envMap) {
          initMaterial(material, scene, object)
        }
      } else {
        initMaterial(material, scene, object)
        materialProperties.__version = material.version
      }

      var refreshProgram = false
      var refreshMaterial = false
      var refreshLights = false
      var program = materialProperties.program,
        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) {
        p_uniforms.setValue(_gl, 'projectionMatrix', camera.projectionMatrix)

        if (capabilities.logarithmicDepthBuffer) {
          p_uniforms.setValue(_gl, 'logDepthBufFC', 2.0 / (Math.log(camera.far + 1.0) / Math.LN2))
        }

        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
        } // load material specific uniforms
        // (shader material also gets them for the sake of genericity)

        if (material.isShaderMaterial || material.isMeshPhongMaterial || material.isMeshToonMaterial || material.isMeshStandardMaterial || material.envMap) {
          var uCamPos = p_uniforms.map.cameraPosition

          if (uCamPos !== undefined) {
            uCamPos.setValue(_gl, _vector3.setFromMatrixPosition(camera.matrixWorld))
          }
        }

        if (
          material.isMeshPhongMaterial ||
          material.isMeshToonMaterial ||
          material.isMeshLambertMaterial ||
          material.isMeshBasicMaterial ||
          material.isMeshStandardMaterial ||
          material.isShaderMaterial
        ) {
          p_uniforms.setValue(_gl, 'isOrthographic', camera.isOrthographicCamera === true)
        }

        if (
          material.isMeshPhongMaterial ||
          material.isMeshToonMaterial ||
          material.isMeshLambertMaterial ||
          material.isMeshBasicMaterial ||
          material.isMeshStandardMaterial ||
          material.isShaderMaterial ||
          material.isShadowMaterial ||
          material.skinning
        ) {
          p_uniforms.setValue(_gl, 'viewMatrix', camera.matrixWorldInverse)
        }
      } // skinning uniforms must be set even if material didn't change
      // auto-setting of texture unit for bone texture must go before other textures
      // otherwise textures used for skinning can take over texture units reserved for other material textures

      if (material.skinning) {
        p_uniforms.setOptional(_gl, object, 'bindMatrix')
        p_uniforms.setOptional(_gl, object, 'bindMatrixInverse')
        var skeleton = object.skeleton

        if (skeleton) {
          var bones = skeleton.bones

          if (capabilities.floatVertexTextures) {
            if (skeleton.boneTexture === null) {
              // 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)
              var size = Math.sqrt(bones.length * 4) // 4 pixels needed for 1 matrix

              size = MathUtils.ceilPowerOfTwo(size)
              size = Math.max(size, 4)
              var boneMatrices = new Float32Array(size * size * 4) // 4 floats per RGBA pixel

              boneMatrices.set(skeleton.boneMatrices) // copy current values

              var boneTexture = new DataTexture(boneMatrices, size, size, RGBAFormat, FloatType)
              skeleton.boneMatrices = boneMatrices
              skeleton.boneTexture = boneTexture
              skeleton.boneTextureSize = size
            }

            p_uniforms.setValue(_gl, 'boneTexture', skeleton.boneTexture, textures)
            p_uniforms.setValue(_gl, 'boneTextureSize', skeleton.boneTextureSize)
          } else {
            p_uniforms.setOptional(_gl, skeleton, 'boneMatrices')
          }
        }
      }

      if (refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow) {
        materialProperties.receiveShadow = object.receiveShadow
        p_uniforms.setValue(_gl, 'receiveShadow', object.receiveShadow)
      }

      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) {
          materials.refreshFogUniforms(m_uniforms, fog)
        }

        materials.refreshMaterialUniforms(m_uniforms, material, _pixelRatio, _height)
        WebGLUniforms.upload(_gl, materialProperties.uniformsList, m_uniforms, textures)
      }

      if (material.isShaderMaterial && material.uniformsNeedUpdate === true) {
        WebGLUniforms.upload(_gl, materialProperties.uniformsList, 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)
      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.setFramebuffer = function (value) {
      if (_framebuffer !== value && _currentRenderTarget === null) _gl.bindFramebuffer(36160, value)
      _framebuffer = value
    }

    this.getActiveCubeFace = function () {
      return _currentActiveCubeFace
    }

    this.getActiveMipmapLevel = function () {
      return _currentActiveMipmapLevel
    }

    this.getRenderList = function () {
      return currentRenderList
    }

    this.setRenderList = function (renderList) {
      currentRenderList = renderList
    }

    this.getRenderTarget = function () {
      return _currentRenderTarget
    }

    this.setRenderTarget = function (renderTarget, activeCubeFace, activeMipmapLevel) {
      if (activeCubeFace === void 0) {
        activeCubeFace = 0
      }

      if (activeMipmapLevel === void 0) {
        activeMipmapLevel = 0
      }

      _currentRenderTarget = renderTarget
      _currentActiveCubeFace = activeCubeFace
      _currentActiveMipmapLevel = activeMipmapLevel

      if (renderTarget && properties.get(renderTarget).__webglFramebuffer === undefined) {
        textures.setupRenderTarget(renderTarget)
      }

      var framebuffer = _framebuffer
      var isCube = false

      if (renderTarget) {
        var __webglFramebuffer = properties.get(renderTarget).__webglFramebuffer

        if (renderTarget.isWebGLCubeRenderTarget) {
          framebuffer = __webglFramebuffer[activeCubeFace]
          isCube = true
        } else if (renderTarget.isWebGLMultisampleRenderTarget) {
          framebuffer = properties.get(renderTarget).__webglMultisampledFramebuffer
        } 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
      }

      if (_currentFramebuffer !== framebuffer) {
        _gl.bindFramebuffer(36160, framebuffer)

        _currentFramebuffer = framebuffer
      }

      state.viewport(_currentViewport)
      state.scissor(_currentScissor)
      state.setScissorTest(_currentScissorTest)

      if (isCube) {
        var textureProperties = properties.get(renderTarget.texture)

        _gl.framebufferTexture2D(36160, 36064, 34069 + activeCubeFace, textureProperties.__webglTexture, activeMipmapLevel)
      }
    }

    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
      }

      var framebuffer = properties.get(renderTarget).__webglFramebuffer

      if (renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined) {
        framebuffer = framebuffer[activeCubeFaceIndex]
      }

      if (framebuffer) {
        var restore = false

        if (framebuffer !== _currentFramebuffer) {
          _gl.bindFramebuffer(36160, framebuffer)

          restore = true
        }

        try {
          var texture = renderTarget.texture
          var textureFormat = texture.format
          var textureType = texture.type

          if (textureFormat !== RGBAFormat && utils.convert(textureFormat) !== _gl.getParameter(35739)) {
            console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.')
            return
          }

          if (
            textureType !== UnsignedByteType &&
            utils.convert(textureType) !== _gl.getParameter(35738) && // IE11, Edge and Chrome Mac < 52 (#9513)
            !(textureType === FloatType && (capabilities.isWebGL2 || extensions.get('OES_texture_float') || extensions.get('WEBGL_color_buffer_float'))) && // Chrome Mac >= 52 and Firefox
            !(textureType === HalfFloatType && (capabilities.isWebGL2 ? extensions.get('EXT_color_buffer_float') : extensions.get('EXT_color_buffer_half_float')))
          ) {
            console.error('THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.')
            return
          }

          if (_gl.checkFramebufferStatus(36160) === 36053) {
            // 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)
            }
          } else {
            console.error('THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.')
          }
        } finally {
          if (restore) {
            _gl.bindFramebuffer(36160, _currentFramebuffer)
          }
        }
      }
    }

    this.copyFramebufferToTexture = function (position, texture, level) {
      if (level === void 0) {
        level = 0
      }

      var levelScale = Math.pow(2, -level)
      var width = Math.floor(texture.image.width * levelScale)
      var height = Math.floor(texture.image.height * levelScale)
      var glFormat = utils.convert(texture.format)
      textures.setTexture2D(texture, 0)

      _gl.copyTexImage2D(3553, level, glFormat, position.x, position.y, width, height, 0)

      state.unbindTexture()
    }

    this.copyTextureToTexture = function (position, srcTexture, dstTexture, level) {
      if (level === void 0) {
        level = 0
      }

      var width = srcTexture.image.width
      var height = srcTexture.image.height
      var glFormat = utils.convert(dstTexture.format)
      var glType = utils.convert(dstTexture.type)
      textures.setTexture2D(dstTexture, 0) // As another texture upload may have changed pixelStorei
      // parameters, make sure they are correct for the dstTexture

      _gl.pixelStorei(37440, dstTexture.flipY)

      _gl.pixelStorei(37441, dstTexture.premultiplyAlpha)

      _gl.pixelStorei(3317, dstTexture.unpackAlignment)

      if (srcTexture.isDataTexture) {
        _gl.texSubImage2D(3553, level, position.x, position.y, width, height, glFormat, glType, srcTexture.image.data)
      } else {
        if (srcTexture.isCompressedTexture) {
          _gl.compressedTexSubImage2D(
            3553,
            level,
            position.x,
            position.y,
            srcTexture.mipmaps[0].width,
            srcTexture.mipmaps[0].height,
            glFormat,
            srcTexture.mipmaps[0].data
          )
        } else {
          _gl.texSubImage2D(3553, level, position.x, position.y, glFormat, glType, srcTexture.image)
        }
      } // Generate mipmaps only when copying level 0

      if (level === 0 && dstTexture.generateMipmaps) _gl.generateMipmap(3553)
      state.unbindTexture()
    }

    this.initTexture = function (texture) {
      textures.setTexture2D(texture, 0)
      state.unbindTexture()
    }

    if (typeof __THREE_DEVTOOLS__ !== 'undefined') {
      __THREE_DEVTOOLS__.dispatchEvent(
        new CustomEvent('observe', {
          detail: this
        })
      ) // eslint-disable-line no-undef
    }
  }

  function WebGL1Renderer(parameters) {
    WebGLRenderer.call(this, parameters)
  }

  WebGL1Renderer.prototype = Object.assign(Object.create(WebGLRenderer.prototype), {
    constructor: WebGL1Renderer,
    isWebGL1Renderer: true
  })

  var FogExp2 = /*#__PURE__*/ (function () {
    function FogExp2(color, density) {
      Object.defineProperty(this, 'isFogExp2', {
        value: true
      })
      this.name = ''
      this.color = new Color(color)
      this.density = density !== undefined ? density : 0.00025
    }

    var _proto = FogExp2.prototype

    _proto.clone = function clone() {
      return new FogExp2(this.color, this.density)
    }

    _proto.toJSON = function toJSON() /* meta */
    {
      return {
        type: 'FogExp2',
        color: this.color.getHex(),
        density: this.density
      }
    }

    return FogExp2
  })()

  var Fog = /*#__PURE__*/ (function () {
    function Fog(color, near, far) {
      Object.defineProperty(this, 'isFog', {
        value: true
      })
      this.name = ''
      this.color = new Color(color)
      this.near = near !== undefined ? near : 1
      this.far = far !== undefined ? far : 1000
    }

    var _proto = Fog.prototype

    _proto.clone = function clone() {
      return new Fog(this.color, this.near, this.far)
    }

    _proto.toJSON = function toJSON() /* meta */
    {
      return {
        type: 'Fog',
        color: this.color.getHex(),
        near: this.near,
        far: this.far
      }
    }

    return Fog
  })()

  var Scene = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(Scene, _Object3D)

    function Scene() {
      var _this

      _this = _Object3D.call(this) || this
      Object.defineProperty(_assertThisInitialized(_this), 'isScene', {
        value: true
      })
      _this.type = 'Scene'
      _this.background = null
      _this.environment = null
      _this.fog = null
      _this.overrideMaterial = null
      _this.autoUpdate = true // checked by the renderer

      if (typeof __THREE_DEVTOOLS__ !== 'undefined') {
        __THREE_DEVTOOLS__.dispatchEvent(
          new CustomEvent('observe', {
            detail: _assertThisInitialized(_this)
          })
        ) // eslint-disable-line no-undef
      }

      return _this
    }

    var _proto = Scene.prototype

    _proto.copy = function copy(source, recursive) {
      _Object3D.prototype.copy.call(this, 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()
      if (source.overrideMaterial !== null) this.overrideMaterial = source.overrideMaterial.clone()
      this.autoUpdate = source.autoUpdate
      this.matrixAutoUpdate = source.matrixAutoUpdate
      return this
    }

    _proto.toJSON = function toJSON(meta) {
      var data = _Object3D.prototype.toJSON.call(this, meta)

      if (this.background !== null) data.object.background = this.background.toJSON(meta)
      if (this.environment !== null) data.object.environment = this.environment.toJSON(meta)
      if (this.fog !== null) data.object.fog = this.fog.toJSON()
      return data
    }

    return Scene
  })(Object3D)

  function InterleavedBuffer(array, stride) {
    this.array = array
    this.stride = stride
    this.count = array !== undefined ? array.length / stride : 0
    this.usage = StaticDrawUsage
    this.updateRange = {
      offset: 0,
      count: -1
    }
    this.version = 0
    this.uuid = MathUtils.generateUUID()
  }

  Object.defineProperty(InterleavedBuffer.prototype, 'needsUpdate', {
    set: function set(value) {
      if (value === true) this.version++
    }
  })
  Object.assign(InterleavedBuffer.prototype, {
    isInterleavedBuffer: true,
    onUploadCallback: function onUploadCallback() {},
    setUsage: function setUsage(value) {
      this.usage = value
      return this
    },
    copy: function 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: function copyAt(index1, attribute, index2) {
      index1 *= this.stride
      index2 *= attribute.stride

      for (var i = 0, l = this.stride; i < l; i++) {
        this.array[index1 + i] = attribute.array[index2 + i]
      }

      return this
    },
    set: function set(value, offset) {
      if (offset === void 0) {
        offset = 0
      }

      this.array.set(value, offset)
      return this
    },
    clone: function clone(data) {
      if (data.arrayBuffers === undefined) {
        data.arrayBuffers = {}
      }

      if (this.array.buffer._uuid === undefined) {
        this.array.buffer._uuid = MathUtils.generateUUID()
      }

      if (data.arrayBuffers[this.array.buffer._uuid] === undefined) {
        data.arrayBuffers[this.array.buffer._uuid] = this.array.slice(0).buffer
      }

      var array = new this.array.constructor(data.arrayBuffers[this.array.buffer._uuid])
      var ib = new InterleavedBuffer(array, this.stride)
      ib.setUsage(this.usage)
      return ib
    },
    onUpload: function onUpload(callback) {
      this.onUploadCallback = callback
      return this
    },
    toJSON: function 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 = MathUtils.generateUUID()
      }

      if (data.arrayBuffers[this.array.buffer._uuid] === undefined) {
        data.arrayBuffers[this.array.buffer._uuid] = Array.prototype.slice.call(new Uint32Array(this.array.buffer))
      } //

      return {
        uuid: this.uuid,
        buffer: this.array.buffer._uuid,
        type: this.array.constructor.name,
        stride: this.stride
      }
    }
  })

  var _vector$6 = new Vector3()

  function InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, normalized) {
    this.name = ''
    this.data = interleavedBuffer
    this.itemSize = itemSize
    this.offset = offset
    this.normalized = normalized === true
  }

  Object.defineProperties(InterleavedBufferAttribute.prototype, {
    count: {
      get: function get() {
        return this.data.count
      }
    },
    array: {
      get: function get() {
        return this.data.array
      }
    },
    needsUpdate: {
      set: function set(value) {
        this.data.needsUpdate = value
      }
    }
  })
  Object.assign(InterleavedBufferAttribute.prototype, {
    isInterleavedBufferAttribute: true,
    applyMatrix4: function applyMatrix4(m) {
      for (var i = 0, l = this.data.count; i < l; i++) {
        _vector$6.x = this.getX(i)
        _vector$6.y = this.getY(i)
        _vector$6.z = this.getZ(i)

        _vector$6.applyMatrix4(m)

        this.setXYZ(i, _vector$6.x, _vector$6.y, _vector$6.z)
      }

      return this
    },
    setX: function setX(index, x) {
      this.data.array[index * this.data.stride + this.offset] = x
      return this
    },
    setY: function setY(index, y) {
      this.data.array[index * this.data.stride + this.offset + 1] = y
      return this
    },
    setZ: function setZ(index, z) {
      this.data.array[index * this.data.stride + this.offset + 2] = z
      return this
    },
    setW: function setW(index, w) {
      this.data.array[index * this.data.stride + this.offset + 3] = w
      return this
    },
    getX: function getX(index) {
      return this.data.array[index * this.data.stride + this.offset]
    },
    getY: function getY(index) {
      return this.data.array[index * this.data.stride + this.offset + 1]
    },
    getZ: function getZ(index) {
      return this.data.array[index * this.data.stride + this.offset + 2]
    },
    getW: function getW(index) {
      return this.data.array[index * this.data.stride + this.offset + 3]
    },
    setXY: function setXY(index, x, y) {
      index = index * this.data.stride + this.offset
      this.data.array[index + 0] = x
      this.data.array[index + 1] = y
      return this
    },
    setXYZ: function setXYZ(index, x, y, z) {
      index = index * this.data.stride + this.offset
      this.data.array[index + 0] = x
      this.data.array[index + 1] = y
      this.data.array[index + 2] = z
      return this
    },
    setXYZW: function setXYZW(index, x, y, z, w) {
      index = index * this.data.stride + this.offset
      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: function clone(data) {
      if (data === undefined) {
        console.log('THREE.InterleavedBufferAttribute.clone(): Cloning an interlaved buffer attribute will deinterleave buffer data.')
        var array = []

        for (var i = 0; i < this.count; i++) {
          var index = i * this.data.stride + this.offset

          for (var j = 0; j < this.itemSize; j++) {
            array.push(this.data.array[index + j])
          }
        }

        return new BufferAttribute(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 InterleavedBufferAttribute(data.interleavedBuffers[this.data.uuid], this.itemSize, this.offset, this.normalized)
      }
    },
    toJSON: function toJSON(data) {
      if (data === undefined) {
        console.log('THREE.InterleavedBufferAttribute.toJSON(): Serializing an interlaved buffer attribute will deinterleave buffer data.')
        var array = []

        for (var i = 0; i < this.count; i++) {
          var index = i * this.data.stride + this.offset

          for (var j = 0; j < this.itemSize; j++) {
            array.push(this.data.array[index + j])
          }
        } // deinterleave 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 interlaved attribtue
        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
        }
      }
    }
  })

  /**
   * parameters = {
   *	color: <hex>,
   *	map: new THREE.Texture( <Image> ),
   *	alphaMap: new THREE.Texture( <Image> ),
   *	rotation: <float>,
   *	sizeAttenuation: <bool>
   * }
   */

  function SpriteMaterial(parameters) {
    Material.call(this)
    this.type = 'SpriteMaterial'
    this.color = new Color(0xffffff)
    this.map = null
    this.alphaMap = null
    this.rotation = 0
    this.sizeAttenuation = true
    this.transparent = true
    this.setValues(parameters)
  }

  SpriteMaterial.prototype = Object.create(Material.prototype)
  SpriteMaterial.prototype.constructor = SpriteMaterial
  SpriteMaterial.prototype.isSpriteMaterial = true

  SpriteMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.color.copy(source.color)
    this.map = source.map
    this.alphaMap = source.alphaMap
    this.rotation = source.rotation
    this.sizeAttenuation = source.sizeAttenuation
    return this
  }

  var _geometry

  var _intersectPoint = new Vector3()

  var _worldScale = new Vector3()

  var _mvPosition = new Vector3()

  var _alignedPosition = new Vector2()

  var _rotatedPosition = new Vector2()

  var _viewWorldMatrix = new Matrix4()

  var _vA$1 = new Vector3()

  var _vB$1 = new Vector3()

  var _vC$1 = new Vector3()

  var _uvA$1 = new Vector2()

  var _uvB$1 = new Vector2()

  var _uvC$1 = new Vector2()

  function Sprite(material) {
    Object3D.call(this)
    this.type = 'Sprite'

    if (_geometry === undefined) {
      _geometry = new BufferGeometry()
      var 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])
      var interleavedBuffer = new InterleavedBuffer(float32Array, 5)

      _geometry.setIndex([0, 1, 2, 0, 2, 3])

      _geometry.setAttribute('position', new InterleavedBufferAttribute(interleavedBuffer, 3, 0, false))

      _geometry.setAttribute('uv', new InterleavedBufferAttribute(interleavedBuffer, 2, 3, false))
    }

    this.geometry = _geometry
    this.material = material !== undefined ? material : new SpriteMaterial()
    this.center = new Vector2(0.5, 0.5)
  }

  Sprite.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Sprite,
    isSprite: true,
    raycast: function raycast(raycaster, intersects) {
      if (raycaster.camera === null) {
        console.error('THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.')
      }

      _worldScale.setFromMatrixScale(this.matrixWorld)

      _viewWorldMatrix.copy(raycaster.camera.matrixWorld)

      this.modelViewMatrix.multiplyMatrices(raycaster.camera.matrixWorldInverse, this.matrixWorld)

      _mvPosition.setFromMatrixPosition(this.modelViewMatrix)

      if (raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false) {
        _worldScale.multiplyScalar(-_mvPosition.z)
      }

      var rotation = this.material.rotation
      var sin, cos

      if (rotation !== 0) {
        cos = Math.cos(rotation)
        sin = Math.sin(rotation)
      }

      var center = this.center
      transformVertex(_vA$1.set(-0.5, -0.5, 0), _mvPosition, center, _worldScale, sin, cos)
      transformVertex(_vB$1.set(0.5, -0.5, 0), _mvPosition, center, _worldScale, sin, cos)
      transformVertex(_vC$1.set(0.5, 0.5, 0), _mvPosition, center, _worldScale, sin, cos)

      _uvA$1.set(0, 0)

      _uvB$1.set(1, 0)

      _uvC$1.set(1, 1) // check first triangle

      var intersect = raycaster.ray.intersectTriangle(_vA$1, _vB$1, _vC$1, false, _intersectPoint)

      if (intersect === null) {
        // check second triangle
        transformVertex(_vB$1.set(-0.5, 0.5, 0), _mvPosition, center, _worldScale, sin, cos)

        _uvB$1.set(0, 1)

        intersect = raycaster.ray.intersectTriangle(_vA$1, _vC$1, _vB$1, false, _intersectPoint)

        if (intersect === null) {
          return
        }
      }

      var distance = raycaster.ray.origin.distanceTo(_intersectPoint)
      if (distance < raycaster.near || distance > raycaster.far) return
      intersects.push({
        distance: distance,
        point: _intersectPoint.clone(),
        uv: Triangle.getUV(_intersectPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2()),
        face: null,
        object: this
      })
    },
    copy: function copy(source) {
      Object3D.prototype.copy.call(this, source)
      if (source.center !== undefined) this.center.copy(source.center)
      this.material = source.material
      return this
    }
  })

  function transformVertex(vertexPosition, mvPosition, center, scale, sin, cos) {
    // compute position in camera space
    _alignedPosition.subVectors(vertexPosition, center).addScalar(0.5).multiply(scale) // to check if rotation is not zero

    if (sin !== undefined) {
      _rotatedPosition.x = cos * _alignedPosition.x - sin * _alignedPosition.y
      _rotatedPosition.y = sin * _alignedPosition.x + cos * _alignedPosition.y
    } else {
      _rotatedPosition.copy(_alignedPosition)
    }

    vertexPosition.copy(mvPosition)
    vertexPosition.x += _rotatedPosition.x
    vertexPosition.y += _rotatedPosition.y // transform to world space

    vertexPosition.applyMatrix4(_viewWorldMatrix)
  }

  var _v1$4 = new Vector3()

  var _v2$2 = new Vector3()

  function LOD() {
    Object3D.call(this)
    this._currentLevel = 0
    this.type = 'LOD'
    Object.defineProperties(this, {
      levels: {
        enumerable: true,
        value: []
      }
    })
    this.autoUpdate = true
  }

  LOD.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: LOD,
    isLOD: true,
    copy: function copy(source) {
      Object3D.prototype.copy.call(this, source, false)
      var levels = source.levels

      for (var i = 0, l = levels.length; i < l; i++) {
        var level = levels[i]
        this.addLevel(level.object.clone(), level.distance)
      }

      this.autoUpdate = source.autoUpdate
      return this
    },
    addLevel: function addLevel(object, distance) {
      if (distance === void 0) {
        distance = 0
      }

      distance = Math.abs(distance)
      var levels = this.levels
      var l

      for (l = 0; l < levels.length; l++) {
        if (distance < levels[l].distance) {
          break
        }
      }

      levels.splice(l, 0, {
        distance: distance,
        object: object
      })
      this.add(object)
      return this
    },
    getCurrentLevel: function getCurrentLevel() {
      return this._currentLevel
    },
    getObjectForDistance: function getObjectForDistance(distance) {
      var levels = this.levels

      if (levels.length > 0) {
        var i, l

        for (i = 1, l = levels.length; i < l; i++) {
          if (distance < levels[i].distance) {
            break
          }
        }

        return levels[i - 1].object
      }

      return null
    },
    raycast: function raycast(raycaster, intersects) {
      var levels = this.levels

      if (levels.length > 0) {
        _v1$4.setFromMatrixPosition(this.matrixWorld)

        var distance = raycaster.ray.origin.distanceTo(_v1$4)
        this.getObjectForDistance(distance).raycast(raycaster, intersects)
      }
    },
    update: function update(camera) {
      var levels = this.levels

      if (levels.length > 1) {
        _v1$4.setFromMatrixPosition(camera.matrixWorld)

        _v2$2.setFromMatrixPosition(this.matrixWorld)

        var distance = _v1$4.distanceTo(_v2$2) / camera.zoom
        levels[0].object.visible = true
        var i, l

        for (i = 1, l = levels.length; i < l; i++) {
          if (distance >= levels[i].distance) {
            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: function toJSON(meta) {
      var data = Object3D.prototype.toJSON.call(this, meta)
      if (this.autoUpdate === false) data.object.autoUpdate = false
      data.object.levels = []
      var levels = this.levels

      for (var i = 0, l = levels.length; i < l; i++) {
        var level = levels[i]
        data.object.levels.push({
          object: level.object.uuid,
          distance: level.distance
        })
      }

      return data
    }
  })

  function SkinnedMesh(geometry, material) {
    if (geometry && geometry.isGeometry) {
      console.error('THREE.SkinnedMesh no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.')
    }

    Mesh.call(this, geometry, material)
    this.type = 'SkinnedMesh'
    this.bindMode = 'attached'
    this.bindMatrix = new Matrix4()
    this.bindMatrixInverse = new Matrix4()
  }

  SkinnedMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
    constructor: SkinnedMesh,
    isSkinnedMesh: true,
    copy: function copy(source) {
      Mesh.prototype.copy.call(this, source)
      this.bindMode = source.bindMode
      this.bindMatrix.copy(source.bindMatrix)
      this.bindMatrixInverse.copy(source.bindMatrixInverse)
      this.skeleton = source.skeleton
      return this
    },
    bind: function 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: function pose() {
      this.skeleton.pose()
    },
    normalizeSkinWeights: function normalizeSkinWeights() {
      var vector = new Vector4()
      var skinWeight = this.geometry.attributes.skinWeight

      for (var i = 0, l = skinWeight.count; i < l; i++) {
        vector.x = skinWeight.getX(i)
        vector.y = skinWeight.getY(i)
        vector.z = skinWeight.getZ(i)
        vector.w = skinWeight.getW(i)
        var 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: function updateMatrixWorld(force) {
      Mesh.prototype.updateMatrixWorld.call(this, force)

      if (this.bindMode === 'attached') {
        this.bindMatrixInverse.copy(this.matrixWorld).invert()
      } else if (this.bindMode === 'detached') {
        this.bindMatrixInverse.copy(this.bindMatrix).invert()
      } else {
        console.warn('THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode)
      }
    },
    boneTransform: (function () {
      var basePosition = new Vector3()
      var skinIndex = new Vector4()
      var skinWeight = new Vector4()
      var vector = new Vector3()
      var matrix = new Matrix4()
      return function (index, target) {
        var skeleton = this.skeleton
        var geometry = this.geometry
        skinIndex.fromBufferAttribute(geometry.attributes.skinIndex, index)
        skinWeight.fromBufferAttribute(geometry.attributes.skinWeight, index)
        basePosition.fromBufferAttribute(geometry.attributes.position, index).applyMatrix4(this.bindMatrix)
        target.set(0, 0, 0)

        for (var i = 0; i < 4; i++) {
          var weight = skinWeight.getComponent(i)

          if (weight !== 0) {
            var boneIndex = skinIndex.getComponent(i)
            matrix.multiplyMatrices(skeleton.bones[boneIndex].matrixWorld, skeleton.boneInverses[boneIndex])
            target.addScaledVector(vector.copy(basePosition).applyMatrix4(matrix), weight)
          }
        }

        return target.applyMatrix4(this.bindMatrixInverse)
      }
    })()
  })

  function Bone() {
    Object3D.call(this)
    this.type = 'Bone'
  }

  Bone.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Bone,
    isBone: true
  })

  var _offsetMatrix = new Matrix4()

  var _identityMatrix = new Matrix4()

  function Skeleton(bones, boneInverses) {
    if (bones === void 0) {
      bones = []
    }

    if (boneInverses === void 0) {
      boneInverses = []
    }

    this.uuid = MathUtils.generateUUID()
    this.bones = bones.slice(0)
    this.boneInverses = boneInverses
    this.boneMatrices = null
    this.boneTexture = null
    this.boneTextureSize = 0
    this.frame = -1
    this.init()
  }

  Object.assign(Skeleton.prototype, {
    init: function init() {
      var bones = this.bones
      var 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 (var i = 0, il = this.bones.length; i < il; i++) {
            this.boneInverses.push(new Matrix4())
          }
        }
      }
    },
    calculateInverses: function calculateInverses() {
      this.boneInverses.length = 0

      for (var i = 0, il = this.bones.length; i < il; i++) {
        var inverse = new Matrix4()

        if (this.bones[i]) {
          inverse.copy(this.bones[i].matrixWorld).invert()
        }

        this.boneInverses.push(inverse)
      }
    },
    pose: function pose() {
      // recover the bind-time world matrices
      for (var i = 0, il = this.bones.length; i < il; i++) {
        var bone = this.bones[i]

        if (bone) {
          bone.matrixWorld.copy(this.boneInverses[i]).invert()
        }
      } // compute the local matrices, positions, rotations and scales

      for (var _i = 0, _il = this.bones.length; _i < _il; _i++) {
        var _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: function update() {
      var bones = this.bones
      var boneInverses = this.boneInverses
      var boneMatrices = this.boneMatrices
      var boneTexture = this.boneTexture // flatten bone matrices to array

      for (var i = 0, il = bones.length; i < il; i++) {
        // compute the offset between the current and the original transform
        var matrix = bones[i] ? bones[i].matrixWorld : _identityMatrix

        _offsetMatrix.multiplyMatrices(matrix, boneInverses[i])

        _offsetMatrix.toArray(boneMatrices, i * 16)
      }

      if (boneTexture !== null) {
        boneTexture.needsUpdate = true
      }
    },
    clone: function clone() {
      return new Skeleton(this.bones, this.boneInverses)
    },
    getBoneByName: function getBoneByName(name) {
      for (var i = 0, il = this.bones.length; i < il; i++) {
        var bone = this.bones[i]

        if (bone.name === name) {
          return bone
        }
      }

      return undefined
    },
    dispose: function dispose() {
      if (this.boneTexture !== null) {
        this.boneTexture.dispose()
        this.boneTexture = null
      }
    },
    fromJSON: function fromJSON(json, bones) {
      this.uuid = json.uuid

      for (var i = 0, l = json.bones.length; i < l; i++) {
        var uuid = json.bones[i]
        var bone = bones[uuid]

        if (bone === undefined) {
          console.warn('THREE.Skeleton: No bone found with UUID:', uuid)
          bone = new Bone()
        }

        this.bones.push(bone)
        this.boneInverses.push(new Matrix4().fromArray(json.boneInverses[i]))
      }

      this.init()
      return this
    },
    toJSON: function toJSON() {
      var data = {
        metadata: {
          version: 4.5,
          type: 'Skeleton',
          generator: 'Skeleton.toJSON'
        },
        bones: [],
        boneInverses: []
      }
      data.uuid = this.uuid
      var bones = this.bones
      var boneInverses = this.boneInverses

      for (var i = 0, l = bones.length; i < l; i++) {
        var bone = bones[i]
        data.bones.push(bone.uuid)
        var boneInverse = boneInverses[i]
        data.boneInverses.push(boneInverse.toArray())
      }

      return data
    }
  })

  var _instanceLocalMatrix = new Matrix4()

  var _instanceWorldMatrix = new Matrix4()

  var _instanceIntersects = []

  var _mesh = new Mesh()

  function InstancedMesh(geometry, material, count) {
    Mesh.call(this, geometry, material)
    this.instanceMatrix = new BufferAttribute(new Float32Array(count * 16), 16)
    this.instanceColor = null
    this.count = count
    this.frustumCulled = false
  }

  InstancedMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
    constructor: InstancedMesh,
    isInstancedMesh: true,
    copy: function copy(source) {
      Mesh.prototype.copy.call(this, source)
      this.instanceMatrix.copy(source.instanceMatrix)
      this.count = source.count
      return this
    },
    getColorAt: function getColorAt(index, color) {
      color.fromArray(this.instanceColor.array, index * 3)
    },
    getMatrixAt: function getMatrixAt(index, matrix) {
      matrix.fromArray(this.instanceMatrix.array, index * 16)
    },
    raycast: function raycast(raycaster, intersects) {
      var matrixWorld = this.matrixWorld
      var raycastTimes = this.count
      _mesh.geometry = this.geometry
      _mesh.material = this.material
      if (_mesh.material === undefined) return

      for (var instanceId = 0; instanceId < raycastTimes; instanceId++) {
        // calculate the world matrix for each instance
        this.getMatrixAt(instanceId, _instanceLocalMatrix)

        _instanceWorldMatrix.multiplyMatrices(matrixWorld, _instanceLocalMatrix) // the mesh represents this single instance

        _mesh.matrixWorld = _instanceWorldMatrix

        _mesh.raycast(raycaster, _instanceIntersects) // process the result of raycast

        for (var i = 0, l = _instanceIntersects.length; i < l; i++) {
          var intersect = _instanceIntersects[i]
          intersect.instanceId = instanceId
          intersect.object = this
          intersects.push(intersect)
        }

        _instanceIntersects.length = 0
      }
    },
    setColorAt: function setColorAt(index, color) {
      if (this.instanceColor === null) {
        this.instanceColor = new BufferAttribute(new Float32Array(this.count * 3), 3)
      }

      color.toArray(this.instanceColor.array, index * 3)
    },
    setMatrixAt: function setMatrixAt(index, matrix) {
      matrix.toArray(this.instanceMatrix.array, index * 16)
    },
    updateMorphTargets: function updateMorphTargets() {},
    dispose: function dispose() {
      this.dispatchEvent({
        type: 'dispose'
      })
    }
  })

  /**
   * parameters = {
   *	color: <hex>,
   *	opacity: <float>,
   *
   *	linewidth: <float>,
   *	linecap: "round",
   *	linejoin: "round"
   * }
   */

  function LineBasicMaterial(parameters) {
    Material.call(this)
    this.type = 'LineBasicMaterial'
    this.color = new Color(0xffffff)
    this.linewidth = 1
    this.linecap = 'round'
    this.linejoin = 'round'
    this.morphTargets = false
    this.setValues(parameters)
  }

  LineBasicMaterial.prototype = Object.create(Material.prototype)
  LineBasicMaterial.prototype.constructor = LineBasicMaterial
  LineBasicMaterial.prototype.isLineBasicMaterial = true

  LineBasicMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.color.copy(source.color)
    this.linewidth = source.linewidth
    this.linecap = source.linecap
    this.linejoin = source.linejoin
    this.morphTargets = source.morphTargets
    return this
  }

  var _start = new Vector3()

  var _end = new Vector3()

  var _inverseMatrix$1 = new Matrix4()

  var _ray$1 = new Ray()

  var _sphere$2 = new Sphere()

  function Line(geometry, material, mode) {
    if (mode === 1) {
      console.error('THREE.Line: parameter THREE.LinePieces no longer supported. Use THREE.LineSegments instead.')
    }

    Object3D.call(this)
    this.type = 'Line'
    this.geometry = geometry !== undefined ? geometry : new BufferGeometry()
    this.material = material !== undefined ? material : new LineBasicMaterial()
    this.updateMorphTargets()
  }

  Line.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Line,
    isLine: true,
    copy: function copy(source) {
      Object3D.prototype.copy.call(this, source)
      this.material = source.material
      this.geometry = source.geometry
      return this
    },
    computeLineDistances: function computeLineDistances() {
      var geometry = this.geometry

      if (geometry.isBufferGeometry) {
        // we assume non-indexed geometry
        if (geometry.index === null) {
          var positionAttribute = geometry.attributes.position
          var lineDistances = [0]

          for (var i = 1, l = positionAttribute.count; i < l; i++) {
            _start.fromBufferAttribute(positionAttribute, i - 1)

            _end.fromBufferAttribute(positionAttribute, i)

            lineDistances[i] = lineDistances[i - 1]
            lineDistances[i] += _start.distanceTo(_end)
          }

          geometry.setAttribute('lineDistance', new Float32BufferAttribute(lineDistances, 1))
        } else {
          console.warn('THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.')
        }
      } else if (geometry.isGeometry) {
        var vertices = geometry.vertices
        var _lineDistances = geometry.lineDistances
        _lineDistances[0] = 0

        for (var _i = 1, _l = vertices.length; _i < _l; _i++) {
          _lineDistances[_i] = _lineDistances[_i - 1]
          _lineDistances[_i] += vertices[_i - 1].distanceTo(vertices[_i])
        }
      }

      return this
    },
    raycast: function raycast(raycaster, intersects) {
      var geometry = this.geometry
      var matrixWorld = this.matrixWorld
      var threshold = raycaster.params.Line.threshold // Checking boundingSphere distance to ray

      if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

      _sphere$2.copy(geometry.boundingSphere)

      _sphere$2.applyMatrix4(matrixWorld)

      _sphere$2.radius += threshold
      if (raycaster.ray.intersectsSphere(_sphere$2) === false) return //

      _inverseMatrix$1.copy(matrixWorld).invert()

      _ray$1.copy(raycaster.ray).applyMatrix4(_inverseMatrix$1)

      var localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3)
      var localThresholdSq = localThreshold * localThreshold
      var vStart = new Vector3()
      var vEnd = new Vector3()
      var interSegment = new Vector3()
      var interRay = new Vector3()
      var step = this.isLineSegments ? 2 : 1

      if (geometry.isBufferGeometry) {
        var index = geometry.index
        var attributes = geometry.attributes
        var positionAttribute = attributes.position

        if (index !== null) {
          var indices = index.array

          for (var i = 0, l = indices.length - 1; i < l; i += step) {
            var a = indices[i]
            var b = indices[i + 1]
            vStart.fromBufferAttribute(positionAttribute, a)
            vEnd.fromBufferAttribute(positionAttribute, b)

            var distSq = _ray$1.distanceSqToSegment(vStart, vEnd, interRay, interSegment)

            if (distSq > localThresholdSq) continue
            interRay.applyMatrix4(this.matrixWorld) //Move back to world space for distance calculation

            var distance = raycaster.ray.origin.distanceTo(interRay)
            if (distance < raycaster.near || distance > raycaster.far) continue
            intersects.push({
              distance: distance,
              // What do we want? intersection point on the ray or on the segment??
              // point: raycaster.ray.at( distance ),
              point: interSegment.clone().applyMatrix4(this.matrixWorld),
              index: i,
              face: null,
              faceIndex: null,
              object: this
            })
          }
        } else {
          for (var _i2 = 0, _l2 = positionAttribute.count - 1; _i2 < _l2; _i2 += step) {
            vStart.fromBufferAttribute(positionAttribute, _i2)
            vEnd.fromBufferAttribute(positionAttribute, _i2 + 1)

            var _distSq = _ray$1.distanceSqToSegment(vStart, vEnd, interRay, interSegment)

            if (_distSq > localThresholdSq) continue
            interRay.applyMatrix4(this.matrixWorld) //Move back to world space for distance calculation

            var _distance = raycaster.ray.origin.distanceTo(interRay)

            if (_distance < raycaster.near || _distance > raycaster.far) continue
            intersects.push({
              distance: _distance,
              // What do we want? intersection point on the ray or on the segment??
              // point: raycaster.ray.at( distance ),
              point: interSegment.clone().applyMatrix4(this.matrixWorld),
              index: _i2,
              face: null,
              faceIndex: null,
              object: this
            })
          }
        }
      } else if (geometry.isGeometry) {
        var vertices = geometry.vertices
        var nbVertices = vertices.length

        for (var _i3 = 0; _i3 < nbVertices - 1; _i3 += step) {
          var _distSq2 = _ray$1.distanceSqToSegment(vertices[_i3], vertices[_i3 + 1], interRay, interSegment)

          if (_distSq2 > localThresholdSq) continue
          interRay.applyMatrix4(this.matrixWorld) //Move back to world space for distance calculation

          var _distance2 = raycaster.ray.origin.distanceTo(interRay)

          if (_distance2 < raycaster.near || _distance2 > raycaster.far) continue
          intersects.push({
            distance: _distance2,
            // What do we want? intersection point on the ray or on the segment??
            // point: raycaster.ray.at( distance ),
            point: interSegment.clone().applyMatrix4(this.matrixWorld),
            index: _i3,
            face: null,
            faceIndex: null,
            object: this
          })
        }
      }
    },
    updateMorphTargets: function updateMorphTargets() {
      var geometry = this.geometry

      if (geometry.isBufferGeometry) {
        var morphAttributes = geometry.morphAttributes
        var keys = Object.keys(morphAttributes)

        if (keys.length > 0) {
          var morphAttribute = morphAttributes[keys[0]]

          if (morphAttribute !== undefined) {
            this.morphTargetInfluences = []
            this.morphTargetDictionary = {}

            for (var m = 0, ml = morphAttribute.length; m < ml; m++) {
              var name = morphAttribute[m].name || String(m)
              this.morphTargetInfluences.push(0)
              this.morphTargetDictionary[name] = m
            }
          }
        }
      } else {
        var morphTargets = geometry.morphTargets

        if (morphTargets !== undefined && morphTargets.length > 0) {
          console.error('THREE.Line.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.')
        }
      }
    }
  })

  var _start$1 = new Vector3()

  var _end$1 = new Vector3()

  function LineSegments(geometry, material) {
    Line.call(this, geometry, material)
    this.type = 'LineSegments'
  }

  LineSegments.prototype = Object.assign(Object.create(Line.prototype), {
    constructor: LineSegments,
    isLineSegments: true,
    computeLineDistances: function computeLineDistances() {
      var geometry = this.geometry

      if (geometry.isBufferGeometry) {
        // we assume non-indexed geometry
        if (geometry.index === null) {
          var positionAttribute = geometry.attributes.position
          var lineDistances = []

          for (var i = 0, l = positionAttribute.count; i < l; i += 2) {
            _start$1.fromBufferAttribute(positionAttribute, i)

            _end$1.fromBufferAttribute(positionAttribute, i + 1)

            lineDistances[i] = i === 0 ? 0 : lineDistances[i - 1]
            lineDistances[i + 1] = lineDistances[i] + _start$1.distanceTo(_end$1)
          }

          geometry.setAttribute('lineDistance', new Float32BufferAttribute(lineDistances, 1))
        } else {
          console.warn('THREE.LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.')
        }
      } else if (geometry.isGeometry) {
        var vertices = geometry.vertices
        var _lineDistances = geometry.lineDistances

        for (var _i = 0, _l = vertices.length; _i < _l; _i += 2) {
          _start$1.copy(vertices[_i])

          _end$1.copy(vertices[_i + 1])

          _lineDistances[_i] = _i === 0 ? 0 : _lineDistances[_i - 1]
          _lineDistances[_i + 1] = _lineDistances[_i] + _start$1.distanceTo(_end$1)
        }
      }

      return this
    }
  })

  function LineLoop(geometry, material) {
    Line.call(this, geometry, material)
    this.type = 'LineLoop'
  }

  LineLoop.prototype = Object.assign(Object.create(Line.prototype), {
    constructor: LineLoop,
    isLineLoop: true
  })

  /**
   * parameters = {
   *	color: <hex>,
   *	opacity: <float>,
   *	map: new THREE.Texture( <Image> ),
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	size: <float>,
   *	sizeAttenuation: <bool>
   *
   *	morphTargets: <bool>
   * }
   */

  function PointsMaterial(parameters) {
    Material.call(this)
    this.type = 'PointsMaterial'
    this.color = new Color(0xffffff)
    this.map = null
    this.alphaMap = null
    this.size = 1
    this.sizeAttenuation = true
    this.morphTargets = false
    this.setValues(parameters)
  }

  PointsMaterial.prototype = Object.create(Material.prototype)
  PointsMaterial.prototype.constructor = PointsMaterial
  PointsMaterial.prototype.isPointsMaterial = true

  PointsMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.color.copy(source.color)
    this.map = source.map
    this.alphaMap = source.alphaMap
    this.size = source.size
    this.sizeAttenuation = source.sizeAttenuation
    this.morphTargets = source.morphTargets
    return this
  }

  var _inverseMatrix$2 = new Matrix4()

  var _ray$2 = new Ray()

  var _sphere$3 = new Sphere()

  var _position$1 = new Vector3()

  function Points(geometry, material) {
    Object3D.call(this)
    this.type = 'Points'
    this.geometry = geometry !== undefined ? geometry : new BufferGeometry()
    this.material = material !== undefined ? material : new PointsMaterial()
    this.updateMorphTargets()
  }

  Points.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Points,
    isPoints: true,
    copy: function copy(source) {
      Object3D.prototype.copy.call(this, source)
      this.material = source.material
      this.geometry = source.geometry
      return this
    },
    raycast: function raycast(raycaster, intersects) {
      var geometry = this.geometry
      var matrixWorld = this.matrixWorld
      var threshold = raycaster.params.Points.threshold // Checking boundingSphere distance to ray

      if (geometry.boundingSphere === null) geometry.computeBoundingSphere()

      _sphere$3.copy(geometry.boundingSphere)

      _sphere$3.applyMatrix4(matrixWorld)

      _sphere$3.radius += threshold
      if (raycaster.ray.intersectsSphere(_sphere$3) === false) return //

      _inverseMatrix$2.copy(matrixWorld).invert()

      _ray$2.copy(raycaster.ray).applyMatrix4(_inverseMatrix$2)

      var localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3)
      var localThresholdSq = localThreshold * localThreshold

      if (geometry.isBufferGeometry) {
        var index = geometry.index
        var attributes = geometry.attributes
        var positionAttribute = attributes.position

        if (index !== null) {
          var indices = index.array

          for (var i = 0, il = indices.length; i < il; i++) {
            var a = indices[i]

            _position$1.fromBufferAttribute(positionAttribute, a)

            testPoint(_position$1, a, localThresholdSq, matrixWorld, raycaster, intersects, this)
          }
        } else {
          for (var _i = 0, l = positionAttribute.count; _i < l; _i++) {
            _position$1.fromBufferAttribute(positionAttribute, _i)

            testPoint(_position$1, _i, localThresholdSq, matrixWorld, raycaster, intersects, this)
          }
        }
      } else {
        var vertices = geometry.vertices

        for (var _i2 = 0, _l = vertices.length; _i2 < _l; _i2++) {
          testPoint(vertices[_i2], _i2, localThresholdSq, matrixWorld, raycaster, intersects, this)
        }
      }
    },
    updateMorphTargets: function updateMorphTargets() {
      var geometry = this.geometry

      if (geometry.isBufferGeometry) {
        var morphAttributes = geometry.morphAttributes
        var keys = Object.keys(morphAttributes)

        if (keys.length > 0) {
          var morphAttribute = morphAttributes[keys[0]]

          if (morphAttribute !== undefined) {
            this.morphTargetInfluences = []
            this.morphTargetDictionary = {}

            for (var m = 0, ml = morphAttribute.length; m < ml; m++) {
              var name = morphAttribute[m].name || String(m)
              this.morphTargetInfluences.push(0)
              this.morphTargetDictionary[name] = m
            }
          }
        }
      } else {
        var morphTargets = geometry.morphTargets

        if (morphTargets !== undefined && morphTargets.length > 0) {
          console.error('THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.')
        }
      }
    }
  })

  function testPoint(point, index, localThresholdSq, matrixWorld, raycaster, intersects, object) {
    var rayPointDistanceSq = _ray$2.distanceSqToPoint(point)

    if (rayPointDistanceSq < localThresholdSq) {
      var intersectPoint = new Vector3()

      _ray$2.closestPointToPoint(point, intersectPoint)

      intersectPoint.applyMatrix4(matrixWorld)
      var 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,
        object: object
      })
    }
  }

  function VideoTexture(video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy) {
    Texture.call(this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy)
    this.format = format !== undefined ? format : RGBFormat
    this.minFilter = minFilter !== undefined ? minFilter : LinearFilter
    this.magFilter = magFilter !== undefined ? magFilter : LinearFilter
    this.generateMipmaps = false
    var scope = this

    function updateVideo() {
      scope.needsUpdate = true
      video.requestVideoFrameCallback(updateVideo)
    }

    if ('requestVideoFrameCallback' in video) {
      video.requestVideoFrameCallback(updateVideo)
    }
  }

  VideoTexture.prototype = Object.assign(Object.create(Texture.prototype), {
    constructor: VideoTexture,
    clone: function clone() {
      return new this.constructor(this.image).copy(this)
    },
    isVideoTexture: true,
    update: function update() {
      var video = this.image
      var hasVideoFrameCallback = 'requestVideoFrameCallback' in video

      if (hasVideoFrameCallback === false && video.readyState >= video.HAVE_CURRENT_DATA) {
        this.needsUpdate = true
      }
    }
  })

  function CompressedTexture(mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding) {
    Texture.call(this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding)
    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
  }

  CompressedTexture.prototype = Object.create(Texture.prototype)
  CompressedTexture.prototype.constructor = CompressedTexture
  CompressedTexture.prototype.isCompressedTexture = true

  function CanvasTexture(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy) {
    Texture.call(this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy)
    this.needsUpdate = true
  }

  CanvasTexture.prototype = Object.create(Texture.prototype)
  CanvasTexture.prototype.constructor = CanvasTexture
  CanvasTexture.prototype.isCanvasTexture = true

  function DepthTexture(width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format) {
    format = format !== undefined ? format : DepthFormat

    if (format !== DepthFormat && format !== DepthStencilFormat) {
      throw new Error('DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat')
    }

    if (type === undefined && format === DepthFormat) type = UnsignedShortType
    if (type === undefined && format === DepthStencilFormat) type = UnsignedInt248Type
    Texture.call(this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy)
    this.image = {
      width: width,
      height: height
    }
    this.magFilter = magFilter !== undefined ? magFilter : NearestFilter
    this.minFilter = minFilter !== undefined ? minFilter : NearestFilter
    this.flipY = false
    this.generateMipmaps = false
  }

  DepthTexture.prototype = Object.create(Texture.prototype)
  DepthTexture.prototype.constructor = DepthTexture
  DepthTexture.prototype.isDepthTexture = true

  var _geometryId = 0 // Geometry uses even numbers as Id

  var _m1$3 = new Matrix4()

  var _obj$1 = new Object3D()

  var _offset$1 = new Vector3()

  function Geometry() {
    Object.defineProperty(this, 'id', {
      value: (_geometryId += 2)
    })
    this.uuid = MathUtils.generateUUID()
    this.name = ''
    this.type = 'Geometry'
    this.vertices = []
    this.colors = []
    this.faces = []
    this.faceVertexUvs = [[]]
    this.morphTargets = []
    this.morphNormals = []
    this.skinWeights = []
    this.skinIndices = []
    this.lineDistances = []
    this.boundingBox = null
    this.boundingSphere = null // update flags

    this.elementsNeedUpdate = false
    this.verticesNeedUpdate = false
    this.uvsNeedUpdate = false
    this.normalsNeedUpdate = false
    this.colorsNeedUpdate = false
    this.lineDistancesNeedUpdate = false
    this.groupsNeedUpdate = false
  }

  Geometry.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: Geometry,
    isGeometry: true,
    applyMatrix4: function applyMatrix4(matrix) {
      var normalMatrix = new Matrix3().getNormalMatrix(matrix)

      for (var i = 0, il = this.vertices.length; i < il; i++) {
        var vertex = this.vertices[i]
        vertex.applyMatrix4(matrix)
      }

      for (var _i = 0, _il = this.faces.length; _i < _il; _i++) {
        var face = this.faces[_i]
        face.normal.applyMatrix3(normalMatrix).normalize()

        for (var j = 0, jl = face.vertexNormals.length; j < jl; j++) {
          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize()
        }
      }

      if (this.boundingBox !== null) {
        this.computeBoundingBox()
      }

      if (this.boundingSphere !== null) {
        this.computeBoundingSphere()
      }

      this.verticesNeedUpdate = true
      this.normalsNeedUpdate = true
      return this
    },
    rotateX: function rotateX(angle) {
      // rotate geometry around world x-axis
      _m1$3.makeRotationX(angle)

      this.applyMatrix4(_m1$3)
      return this
    },
    rotateY: function rotateY(angle) {
      // rotate geometry around world y-axis
      _m1$3.makeRotationY(angle)

      this.applyMatrix4(_m1$3)
      return this
    },
    rotateZ: function rotateZ(angle) {
      // rotate geometry around world z-axis
      _m1$3.makeRotationZ(angle)

      this.applyMatrix4(_m1$3)
      return this
    },
    translate: function translate(x, y, z) {
      // translate geometry
      _m1$3.makeTranslation(x, y, z)

      this.applyMatrix4(_m1$3)
      return this
    },
    scale: function scale(x, y, z) {
      // scale geometry
      _m1$3.makeScale(x, y, z)

      this.applyMatrix4(_m1$3)
      return this
    },
    lookAt: function lookAt(vector) {
      _obj$1.lookAt(vector)

      _obj$1.updateMatrix()

      this.applyMatrix4(_obj$1.matrix)
      return this
    },
    fromBufferGeometry: function fromBufferGeometry(geometry) {
      var scope = this
      var index = geometry.index !== null ? geometry.index : undefined
      var attributes = geometry.attributes

      if (attributes.position === undefined) {
        console.error('THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.')
        return this
      }

      var position = attributes.position
      var normal = attributes.normal
      var color = attributes.color
      var uv = attributes.uv
      var uv2 = attributes.uv2
      if (uv2 !== undefined) this.faceVertexUvs[1] = []

      for (var i = 0; i < position.count; i++) {
        scope.vertices.push(new Vector3().fromBufferAttribute(position, i))

        if (color !== undefined) {
          scope.colors.push(new Color().fromBufferAttribute(color, i))
        }
      }

      function addFace(a, b, c, materialIndex) {
        var vertexColors = color === undefined ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()]
        var vertexNormals =
          normal === undefined
            ? []
            : [new Vector3().fromBufferAttribute(normal, a), new Vector3().fromBufferAttribute(normal, b), new Vector3().fromBufferAttribute(normal, c)]
        var face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex)
        scope.faces.push(face)

        if (uv !== undefined) {
          scope.faceVertexUvs[0].push([new Vector2().fromBufferAttribute(uv, a), new Vector2().fromBufferAttribute(uv, b), new Vector2().fromBufferAttribute(uv, c)])
        }

        if (uv2 !== undefined) {
          scope.faceVertexUvs[1].push([new Vector2().fromBufferAttribute(uv2, a), new Vector2().fromBufferAttribute(uv2, b), new Vector2().fromBufferAttribute(uv2, c)])
        }
      }

      var groups = geometry.groups

      if (groups.length > 0) {
        for (var _i2 = 0; _i2 < groups.length; _i2++) {
          var group = groups[_i2]
          var start = group.start
          var count = group.count

          for (var j = start, jl = start + count; j < jl; j += 3) {
            if (index !== undefined) {
              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex)
            } else {
              addFace(j, j + 1, j + 2, group.materialIndex)
            }
          }
        }
      } else {
        if (index !== undefined) {
          for (var _i3 = 0; _i3 < index.count; _i3 += 3) {
            addFace(index.getX(_i3), index.getX(_i3 + 1), index.getX(_i3 + 2))
          }
        } else {
          for (var _i4 = 0; _i4 < position.count; _i4 += 3) {
            addFace(_i4, _i4 + 1, _i4 + 2)
          }
        }
      }

      this.computeFaceNormals()

      if (geometry.boundingBox !== null) {
        this.boundingBox = geometry.boundingBox.clone()
      }

      if (geometry.boundingSphere !== null) {
        this.boundingSphere = geometry.boundingSphere.clone()
      }

      return this
    },
    center: function center() {
      this.computeBoundingBox()
      this.boundingBox.getCenter(_offset$1).negate()
      this.translate(_offset$1.x, _offset$1.y, _offset$1.z)
      return this
    },
    normalize: function normalize() {
      this.computeBoundingSphere()
      var center = this.boundingSphere.center
      var radius = this.boundingSphere.radius
      var s = radius === 0 ? 1 : 1.0 / radius
      var matrix = new Matrix4()
      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1)
      this.applyMatrix4(matrix)
      return this
    },
    computeFaceNormals: function computeFaceNormals() {
      var cb = new Vector3(),
        ab = new Vector3()

      for (var f = 0, fl = this.faces.length; f < fl; f++) {
        var face = this.faces[f]
        var vA = this.vertices[face.a]
        var vB = this.vertices[face.b]
        var vC = this.vertices[face.c]
        cb.subVectors(vC, vB)
        ab.subVectors(vA, vB)
        cb.cross(ab)
        cb.normalize()
        face.normal.copy(cb)
      }
    },
    computeVertexNormals: function computeVertexNormals(areaWeighted) {
      if (areaWeighted === void 0) {
        areaWeighted = true
      }

      var vertices = new Array(this.vertices.length)

      for (var v = 0, vl = this.vertices.length; v < vl; v++) {
        vertices[v] = new Vector3()
      }

      if (areaWeighted) {
        // vertex normals weighted by triangle areas
        // http://www.iquilezles.org/www/articles/normals/normals.htm
        var cb = new Vector3(),
          ab = new Vector3()

        for (var f = 0, fl = this.faces.length; f < fl; f++) {
          var face = this.faces[f]
          var vA = this.vertices[face.a]
          var vB = this.vertices[face.b]
          var vC = this.vertices[face.c]
          cb.subVectors(vC, vB)
          ab.subVectors(vA, vB)
          cb.cross(ab)
          vertices[face.a].add(cb)
          vertices[face.b].add(cb)
          vertices[face.c].add(cb)
        }
      } else {
        this.computeFaceNormals()

        for (var _f = 0, _fl = this.faces.length; _f < _fl; _f++) {
          var _face = this.faces[_f]

          vertices[_face.a].add(_face.normal)

          vertices[_face.b].add(_face.normal)

          vertices[_face.c].add(_face.normal)
        }
      }

      for (var _v = 0, _vl = this.vertices.length; _v < _vl; _v++) {
        vertices[_v].normalize()
      }

      for (var _f2 = 0, _fl2 = this.faces.length; _f2 < _fl2; _f2++) {
        var _face2 = this.faces[_f2]
        var vertexNormals = _face2.vertexNormals

        if (vertexNormals.length === 3) {
          vertexNormals[0].copy(vertices[_face2.a])
          vertexNormals[1].copy(vertices[_face2.b])
          vertexNormals[2].copy(vertices[_face2.c])
        } else {
          vertexNormals[0] = vertices[_face2.a].clone()
          vertexNormals[1] = vertices[_face2.b].clone()
          vertexNormals[2] = vertices[_face2.c].clone()
        }
      }

      if (this.faces.length > 0) {
        this.normalsNeedUpdate = true
      }
    },
    computeFlatVertexNormals: function computeFlatVertexNormals() {
      this.computeFaceNormals()

      for (var f = 0, fl = this.faces.length; f < fl; f++) {
        var face = this.faces[f]
        var vertexNormals = face.vertexNormals

        if (vertexNormals.length === 3) {
          vertexNormals[0].copy(face.normal)
          vertexNormals[1].copy(face.normal)
          vertexNormals[2].copy(face.normal)
        } else {
          vertexNormals[0] = face.normal.clone()
          vertexNormals[1] = face.normal.clone()
          vertexNormals[2] = face.normal.clone()
        }
      }

      if (this.faces.length > 0) {
        this.normalsNeedUpdate = true
      }
    },
    computeMorphNormals: function computeMorphNormals() {
      // save original normals
      // - create temp variables on first access
      //	 otherwise just copy (for faster repeated calls)
      for (var f = 0, fl = this.faces.length; f < fl; f++) {
        var face = this.faces[f]

        if (!face.__originalFaceNormal) {
          face.__originalFaceNormal = face.normal.clone()
        } else {
          face.__originalFaceNormal.copy(face.normal)
        }

        if (!face.__originalVertexNormals) face.__originalVertexNormals = []

        for (var i = 0, il = face.vertexNormals.length; i < il; i++) {
          if (!face.__originalVertexNormals[i]) {
            face.__originalVertexNormals[i] = face.vertexNormals[i].clone()
          } else {
            face.__originalVertexNormals[i].copy(face.vertexNormals[i])
          }
        }
      } // use temp geometry to compute face and vertex normals for each morph

      var tmpGeo = new Geometry()
      tmpGeo.faces = this.faces

      for (var _i5 = 0, _il2 = this.morphTargets.length; _i5 < _il2; _i5++) {
        // create on first access
        if (!this.morphNormals[_i5]) {
          this.morphNormals[_i5] = {}
          this.morphNormals[_i5].faceNormals = []
          this.morphNormals[_i5].vertexNormals = []
          var dstNormalsFace = this.morphNormals[_i5].faceNormals
          var dstNormalsVertex = this.morphNormals[_i5].vertexNormals

          for (var _f3 = 0, _fl3 = this.faces.length; _f3 < _fl3; _f3++) {
            var faceNormal = new Vector3()
            var vertexNormals = {
              a: new Vector3(),
              b: new Vector3(),
              c: new Vector3()
            }
            dstNormalsFace.push(faceNormal)
            dstNormalsVertex.push(vertexNormals)
          }
        }

        var morphNormals = this.morphNormals[_i5] // set vertices to morph target

        tmpGeo.vertices = this.morphTargets[_i5].vertices // compute morph normals

        tmpGeo.computeFaceNormals()
        tmpGeo.computeVertexNormals() // store morph normals

        for (var _f4 = 0, _fl4 = this.faces.length; _f4 < _fl4; _f4++) {
          var _face3 = this.faces[_f4]
          var _faceNormal = morphNormals.faceNormals[_f4]
          var _vertexNormals = morphNormals.vertexNormals[_f4]

          _faceNormal.copy(_face3.normal)

          _vertexNormals.a.copy(_face3.vertexNormals[0])

          _vertexNormals.b.copy(_face3.vertexNormals[1])

          _vertexNormals.c.copy(_face3.vertexNormals[2])
        }
      } // restore original normals

      for (var _f5 = 0, _fl5 = this.faces.length; _f5 < _fl5; _f5++) {
        var _face4 = this.faces[_f5]
        _face4.normal = _face4.__originalFaceNormal
        _face4.vertexNormals = _face4.__originalVertexNormals
      }
    },
    computeBoundingBox: function computeBoundingBox() {
      if (this.boundingBox === null) {
        this.boundingBox = new Box3()
      }

      this.boundingBox.setFromPoints(this.vertices)
    },
    computeBoundingSphere: function computeBoundingSphere() {
      if (this.boundingSphere === null) {
        this.boundingSphere = new Sphere()
      }

      this.boundingSphere.setFromPoints(this.vertices)
    },
    merge: function merge(geometry, matrix, materialIndexOffset) {
      if (materialIndexOffset === void 0) {
        materialIndexOffset = 0
      }

      if (!(geometry && geometry.isGeometry)) {
        console.error('THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry)
        return
      }

      var normalMatrix
      var vertexOffset = this.vertices.length,
        vertices1 = this.vertices,
        vertices2 = geometry.vertices,
        faces1 = this.faces,
        faces2 = geometry.faces,
        colors1 = this.colors,
        colors2 = geometry.colors

      if (matrix !== undefined) {
        normalMatrix = new Matrix3().getNormalMatrix(matrix)
      } // vertices

      for (var i = 0, il = vertices2.length; i < il; i++) {
        var vertex = vertices2[i]
        var vertexCopy = vertex.clone()
        if (matrix !== undefined) vertexCopy.applyMatrix4(matrix)
        vertices1.push(vertexCopy)
      } // colors

      for (var _i6 = 0, _il3 = colors2.length; _i6 < _il3; _i6++) {
        colors1.push(colors2[_i6].clone())
      } // faces

      for (var _i7 = 0, _il4 = faces2.length; _i7 < _il4; _i7++) {
        var face = faces2[_i7]
        var normal = void 0,
          color = void 0
        var faceVertexNormals = face.vertexNormals,
          faceVertexColors = face.vertexColors
        var faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset)
        faceCopy.normal.copy(face.normal)

        if (normalMatrix !== undefined) {
          faceCopy.normal.applyMatrix3(normalMatrix).normalize()
        }

        for (var j = 0, jl = faceVertexNormals.length; j < jl; j++) {
          normal = faceVertexNormals[j].clone()

          if (normalMatrix !== undefined) {
            normal.applyMatrix3(normalMatrix).normalize()
          }

          faceCopy.vertexNormals.push(normal)
        }

        faceCopy.color.copy(face.color)

        for (var _j = 0, _jl = faceVertexColors.length; _j < _jl; _j++) {
          color = faceVertexColors[_j]
          faceCopy.vertexColors.push(color.clone())
        }

        faceCopy.materialIndex = face.materialIndex + materialIndexOffset
        faces1.push(faceCopy)
      } // uvs

      for (var _i8 = 0, _il5 = geometry.faceVertexUvs.length; _i8 < _il5; _i8++) {
        var faceVertexUvs2 = geometry.faceVertexUvs[_i8]
        if (this.faceVertexUvs[_i8] === undefined) this.faceVertexUvs[_i8] = []

        for (var _j2 = 0, _jl2 = faceVertexUvs2.length; _j2 < _jl2; _j2++) {
          var uvs2 = faceVertexUvs2[_j2],
            uvsCopy = []

          for (var k = 0, kl = uvs2.length; k < kl; k++) {
            uvsCopy.push(uvs2[k].clone())
          }

          this.faceVertexUvs[_i8].push(uvsCopy)
        }
      }
    },
    mergeMesh: function mergeMesh(mesh) {
      if (!(mesh && mesh.isMesh)) {
        console.error('THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh)
        return
      }

      if (mesh.matrixAutoUpdate) mesh.updateMatrix()
      this.merge(mesh.geometry, mesh.matrix)
    },

    /*
     * Checks for duplicate vertices with hashmap.
     * Duplicated vertices are removed
     * and faces' vertices are updated.
     */
    mergeVertices: function mergeVertices(precisionPoints) {
      if (precisionPoints === void 0) {
        precisionPoints = 4
      }

      var verticesMap = {} // Hashmap for looking up vertices by position coordinates (and making sure they are unique)

      var unique = [],
        changes = []
      var precision = Math.pow(10, precisionPoints)

      for (var i = 0, il = this.vertices.length; i < il; i++) {
        var v = this.vertices[i]
        var key = Math.round(v.x * precision) + '_' + Math.round(v.y * precision) + '_' + Math.round(v.z * precision)

        if (verticesMap[key] === undefined) {
          verticesMap[key] = i
          unique.push(this.vertices[i])
          changes[i] = unique.length - 1
        } else {
          //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
          changes[i] = changes[verticesMap[key]]
        }
      } // if faces are completely degenerate after merging vertices, we
      // have to remove them from the geometry.

      var faceIndicesToRemove = []

      for (var _i9 = 0, _il6 = this.faces.length; _i9 < _il6; _i9++) {
        var face = this.faces[_i9]
        face.a = changes[face.a]
        face.b = changes[face.b]
        face.c = changes[face.c]
        var indices = [face.a, face.b, face.c] // if any duplicate vertices are found in a Face3
        // we have to remove the face as nothing can be saved

        for (var n = 0; n < 3; n++) {
          if (indices[n] === indices[(n + 1) % 3]) {
            faceIndicesToRemove.push(_i9)
            break
          }
        }
      }

      for (var _i10 = faceIndicesToRemove.length - 1; _i10 >= 0; _i10--) {
        var idx = faceIndicesToRemove[_i10]
        this.faces.splice(idx, 1)

        for (var j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
          this.faceVertexUvs[j].splice(idx, 1)
        }
      } // Use unique set of vertices

      var diff = this.vertices.length - unique.length
      this.vertices = unique
      return diff
    },
    setFromPoints: function setFromPoints(points) {
      this.vertices = []

      for (var i = 0, l = points.length; i < l; i++) {
        var point = points[i]
        this.vertices.push(new Vector3(point.x, point.y, point.z || 0))
      }

      return this
    },
    sortFacesByMaterialIndex: function sortFacesByMaterialIndex() {
      var faces = this.faces
      var length = faces.length // tag faces

      for (var i = 0; i < length; i++) {
        faces[i]._id = i
      } // sort faces

      function materialIndexSort(a, b) {
        return a.materialIndex - b.materialIndex
      }

      faces.sort(materialIndexSort) // sort uvs

      var uvs1 = this.faceVertexUvs[0]
      var uvs2 = this.faceVertexUvs[1]
      var newUvs1, newUvs2
      if (uvs1 && uvs1.length === length) newUvs1 = []
      if (uvs2 && uvs2.length === length) newUvs2 = []

      for (var _i11 = 0; _i11 < length; _i11++) {
        var id = faces[_i11]._id
        if (newUvs1) newUvs1.push(uvs1[id])
        if (newUvs2) newUvs2.push(uvs2[id])
      }

      if (newUvs1) this.faceVertexUvs[0] = newUvs1
      if (newUvs2) this.faceVertexUvs[1] = newUvs2
    },
    toJSON: function toJSON() {
      var data = {
        metadata: {
          version: 4.5,
          type: 'Geometry',
          generator: 'Geometry.toJSON'
        }
      } // standard Geometry serialization

      data.uuid = this.uuid
      data.type = this.type
      if (this.name !== '') data.name = this.name

      if (this.parameters !== undefined) {
        var parameters = this.parameters

        for (var key in parameters) {
          if (parameters[key] !== undefined) data[key] = parameters[key]
        }

        return data
      }

      var vertices = []

      for (var i = 0; i < this.vertices.length; i++) {
        var vertex = this.vertices[i]
        vertices.push(vertex.x, vertex.y, vertex.z)
      }

      var faces = []
      var normals = []
      var normalsHash = {}
      var colors = []
      var colorsHash = {}
      var uvs = []
      var uvsHash = {}

      for (var _i12 = 0; _i12 < this.faces.length; _i12++) {
        var face = this.faces[_i12]
        var hasMaterial = true
        var hasFaceUv = false // deprecated

        var hasFaceVertexUv = this.faceVertexUvs[0][_i12] !== undefined
        var hasFaceNormal = face.normal.length() > 0
        var hasFaceVertexNormal = face.vertexNormals.length > 0
        var hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1
        var hasFaceVertexColor = face.vertexColors.length > 0
        var faceType = 0
        faceType = setBit(faceType, 0, 0) // isQuad

        faceType = setBit(faceType, 1, hasMaterial)
        faceType = setBit(faceType, 2, hasFaceUv)
        faceType = setBit(faceType, 3, hasFaceVertexUv)
        faceType = setBit(faceType, 4, hasFaceNormal)
        faceType = setBit(faceType, 5, hasFaceVertexNormal)
        faceType = setBit(faceType, 6, hasFaceColor)
        faceType = setBit(faceType, 7, hasFaceVertexColor)
        faces.push(faceType)
        faces.push(face.a, face.b, face.c)
        faces.push(face.materialIndex)

        if (hasFaceVertexUv) {
          var faceVertexUvs = this.faceVertexUvs[0][_i12]
          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]))
        }

        if (hasFaceNormal) {
          faces.push(getNormalIndex(face.normal))
        }

        if (hasFaceVertexNormal) {
          var vertexNormals = face.vertexNormals
          faces.push(getNormalIndex(vertexNormals[0]), getNormalIndex(vertexNormals[1]), getNormalIndex(vertexNormals[2]))
        }

        if (hasFaceColor) {
          faces.push(getColorIndex(face.color))
        }

        if (hasFaceVertexColor) {
          var vertexColors = face.vertexColors
          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]))
        }
      }

      function setBit(value, position, enabled) {
        return enabled ? value | (1 << position) : value & ~(1 << position)
      }

      function getNormalIndex(normal) {
        var hash = normal.x.toString() + normal.y.toString() + normal.z.toString()

        if (normalsHash[hash] !== undefined) {
          return normalsHash[hash]
        }

        normalsHash[hash] = normals.length / 3
        normals.push(normal.x, normal.y, normal.z)
        return normalsHash[hash]
      }

      function getColorIndex(color) {
        var hash = color.r.toString() + color.g.toString() + color.b.toString()

        if (colorsHash[hash] !== undefined) {
          return colorsHash[hash]
        }

        colorsHash[hash] = colors.length
        colors.push(color.getHex())
        return colorsHash[hash]
      }

      function getUvIndex(uv) {
        var hash = uv.x.toString() + uv.y.toString()

        if (uvsHash[hash] !== undefined) {
          return uvsHash[hash]
        }

        uvsHash[hash] = uvs.length / 2
        uvs.push(uv.x, uv.y)
        return uvsHash[hash]
      }

      data.data = {}
      data.data.vertices = vertices
      data.data.normals = normals
      if (colors.length > 0) data.data.colors = colors
      if (uvs.length > 0) data.data.uvs = [uvs] // temporal backward compatibility

      data.data.faces = faces
      return data
    },
    clone: function clone() {
      /*
			 // Handle primitives
				 const parameters = this.parameters;
				 if ( parameters !== undefined ) {
				 const values = [];
				 for ( const key in parameters ) {
				 values.push( parameters[ key ] );
				 }
				 const geometry = Object.create( this.constructor.prototype );
			 this.constructor.apply( geometry, values );
			 return geometry;
				 }
				 return new this.constructor().copy( this );
			 */
      return new Geometry().copy(this)
    },
    copy: function copy(source) {
      // reset
      this.vertices = []
      this.colors = []
      this.faces = []
      this.faceVertexUvs = [[]]
      this.morphTargets = []
      this.morphNormals = []
      this.skinWeights = []
      this.skinIndices = []
      this.lineDistances = []
      this.boundingBox = null
      this.boundingSphere = null // name

      this.name = source.name // vertices

      var vertices = source.vertices

      for (var i = 0, il = vertices.length; i < il; i++) {
        this.vertices.push(vertices[i].clone())
      } // colors

      var colors = source.colors

      for (var _i13 = 0, _il7 = colors.length; _i13 < _il7; _i13++) {
        this.colors.push(colors[_i13].clone())
      } // faces

      var faces = source.faces

      for (var _i14 = 0, _il8 = faces.length; _i14 < _il8; _i14++) {
        this.faces.push(faces[_i14].clone())
      } // face vertex uvs

      for (var _i15 = 0, _il9 = source.faceVertexUvs.length; _i15 < _il9; _i15++) {
        var faceVertexUvs = source.faceVertexUvs[_i15]

        if (this.faceVertexUvs[_i15] === undefined) {
          this.faceVertexUvs[_i15] = []
        }

        for (var j = 0, jl = faceVertexUvs.length; j < jl; j++) {
          var uvs = faceVertexUvs[j],
            uvsCopy = []

          for (var k = 0, kl = uvs.length; k < kl; k++) {
            var uv = uvs[k]
            uvsCopy.push(uv.clone())
          }

          this.faceVertexUvs[_i15].push(uvsCopy)
        }
      } // morph targets

      var morphTargets = source.morphTargets

      for (var _i16 = 0, _il10 = morphTargets.length; _i16 < _il10; _i16++) {
        var morphTarget = {}
        morphTarget.name = morphTargets[_i16].name // vertices

        if (morphTargets[_i16].vertices !== undefined) {
          morphTarget.vertices = []

          for (var _j3 = 0, _jl3 = morphTargets[_i16].vertices.length; _j3 < _jl3; _j3++) {
            morphTarget.vertices.push(morphTargets[_i16].vertices[_j3].clone())
          }
        } // normals

        if (morphTargets[_i16].normals !== undefined) {
          morphTarget.normals = []

          for (var _j4 = 0, _jl4 = morphTargets[_i16].normals.length; _j4 < _jl4; _j4++) {
            morphTarget.normals.push(morphTargets[_i16].normals[_j4].clone())
          }
        }

        this.morphTargets.push(morphTarget)
      } // morph normals

      var morphNormals = source.morphNormals

      for (var _i17 = 0, _il11 = morphNormals.length; _i17 < _il11; _i17++) {
        var morphNormal = {} // vertex normals

        if (morphNormals[_i17].vertexNormals !== undefined) {
          morphNormal.vertexNormals = []

          for (var _j5 = 0, _jl5 = morphNormals[_i17].vertexNormals.length; _j5 < _jl5; _j5++) {
            var srcVertexNormal = morphNormals[_i17].vertexNormals[_j5]
            var destVertexNormal = {}
            destVertexNormal.a = srcVertexNormal.a.clone()
            destVertexNormal.b = srcVertexNormal.b.clone()
            destVertexNormal.c = srcVertexNormal.c.clone()
            morphNormal.vertexNormals.push(destVertexNormal)
          }
        } // face normals

        if (morphNormals[_i17].faceNormals !== undefined) {
          morphNormal.faceNormals = []

          for (var _j6 = 0, _jl6 = morphNormals[_i17].faceNormals.length; _j6 < _jl6; _j6++) {
            morphNormal.faceNormals.push(morphNormals[_i17].faceNormals[_j6].clone())
          }
        }

        this.morphNormals.push(morphNormal)
      } // skin weights

      var skinWeights = source.skinWeights

      for (var _i18 = 0, _il12 = skinWeights.length; _i18 < _il12; _i18++) {
        this.skinWeights.push(skinWeights[_i18].clone())
      } // skin indices

      var skinIndices = source.skinIndices

      for (var _i19 = 0, _il13 = skinIndices.length; _i19 < _il13; _i19++) {
        this.skinIndices.push(skinIndices[_i19].clone())
      } // line distances

      var lineDistances = source.lineDistances

      for (var _i20 = 0, _il14 = lineDistances.length; _i20 < _il14; _i20++) {
        this.lineDistances.push(lineDistances[_i20])
      } // bounding box

      var boundingBox = source.boundingBox

      if (boundingBox !== null) {
        this.boundingBox = boundingBox.clone()
      } // bounding sphere

      var boundingSphere = source.boundingSphere

      if (boundingSphere !== null) {
        this.boundingSphere = boundingSphere.clone()
      } // update flags

      this.elementsNeedUpdate = source.elementsNeedUpdate
      this.verticesNeedUpdate = source.verticesNeedUpdate
      this.uvsNeedUpdate = source.uvsNeedUpdate
      this.normalsNeedUpdate = source.normalsNeedUpdate
      this.colorsNeedUpdate = source.colorsNeedUpdate
      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate
      this.groupsNeedUpdate = source.groupsNeedUpdate
      return this
    },
    dispose: function dispose() {
      this.dispatchEvent({
        type: 'dispose'
      })
    }
  })

  var BoxGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(BoxGeometry, _Geometry)

    function BoxGeometry(width, height, depth, widthSegments, heightSegments, depthSegments) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'BoxGeometry'
      _this.parameters = {
        width: width,
        height: height,
        depth: depth,
        widthSegments: widthSegments,
        heightSegments: heightSegments,
        depthSegments: depthSegments
      }

      _this.fromBufferGeometry(new BoxBufferGeometry(width, height, depth, widthSegments, heightSegments, depthSegments))

      _this.mergeVertices()

      return _this
    }

    return BoxGeometry
  })(Geometry)

  var CircleBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(CircleBufferGeometry, _BufferGeometry)

    function CircleBufferGeometry(radius, segments, thetaStart, thetaLength) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (segments === void 0) {
        segments = 8
      }

      if (thetaStart === void 0) {
        thetaStart = 0
      }

      if (thetaLength === void 0) {
        thetaLength = Math.PI * 2
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'CircleBufferGeometry'
      _this.parameters = {
        radius: radius,
        segments: segments,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }
      segments = Math.max(3, segments) // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // helper variables

      var vertex = new Vector3()
      var uv = new Vector2() // center point

      vertices.push(0, 0, 0)
      normals.push(0, 0, 1)
      uvs.push(0.5, 0.5)

      for (var s = 0, i = 3; s <= segments; s++, i += 3) {
        var 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 (var _i = 1; _i <= segments; _i++) {
        indices.push(_i, _i + 1, 0)
      } // build geometry

      _this.setIndex(indices)

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      return _this
    }

    return CircleBufferGeometry
  })(BufferGeometry)

  var CircleGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(CircleGeometry, _Geometry)

    function CircleGeometry(radius, segments, thetaStart, thetaLength) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'CircleGeometry'
      _this.parameters = {
        radius: radius,
        segments: segments,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }

      _this.fromBufferGeometry(new CircleBufferGeometry(radius, segments, thetaStart, thetaLength))

      _this.mergeVertices()

      return _this
    }

    return CircleGeometry
  })(Geometry)

  var CylinderBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(CylinderBufferGeometry, _BufferGeometry)

    function CylinderBufferGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
      var _this

      if (radiusTop === void 0) {
        radiusTop = 1
      }

      if (radiusBottom === void 0) {
        radiusBottom = 1
      }

      if (height === void 0) {
        height = 1
      }

      if (radialSegments === void 0) {
        radialSegments = 8
      }

      if (heightSegments === void 0) {
        heightSegments = 1
      }

      if (openEnded === void 0) {
        openEnded = false
      }

      if (thetaStart === void 0) {
        thetaStart = 0
      }

      if (thetaLength === void 0) {
        thetaLength = Math.PI * 2
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'CylinderBufferGeometry'
      _this.parameters = {
        radiusTop: radiusTop,
        radiusBottom: radiusBottom,
        height: height,
        radialSegments: radialSegments,
        heightSegments: heightSegments,
        openEnded: openEnded,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }

      var scope = _assertThisInitialized(_this)

      radialSegments = Math.floor(radialSegments)
      heightSegments = Math.floor(heightSegments) // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // helper variables

      var index = 0
      var indexArray = []
      var halfHeight = height / 2
      var 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 Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      function generateTorso() {
        var normal = new Vector3()
        var vertex = new Vector3()
        var groupCount = 0 // this will be used to calculate the normal

        var slope = (radiusBottom - radiusTop) / height // generate vertices, normals and uvs

        for (var y = 0; y <= heightSegments; y++) {
          var indexRow = []
          var v = y / heightSegments // calculate the radius of the current row

          var radius = v * (radiusBottom - radiusTop) + radiusTop

          for (var x = 0; x <= radialSegments; x++) {
            var u = x / radialSegments
            var theta = u * thetaLength + thetaStart
            var sinTheta = Math.sin(theta)
            var 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 (var _x = 0; _x < radialSegments; _x++) {
          for (var _y = 0; _y < heightSegments; _y++) {
            // we use the index array to access the correct indices
            var a = indexArray[_y][_x]
            var b = indexArray[_y + 1][_x]
            var c = indexArray[_y + 1][_x + 1]
            var d = indexArray[_y][_x + 1] // faces

            indices.push(a, b, d)
            indices.push(b, c, d) // update group counter

            groupCount += 6
          }
        } // 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
        var centerIndexStart = index
        var uv = new Vector2()
        var vertex = new Vector3()
        var groupCount = 0
        var radius = top === true ? radiusTop : radiusBottom
        var 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 (var 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

        var centerIndexEnd = index // now we generate the surrounding vertices, normals and uvs

        for (var _x2 = 0; _x2 <= radialSegments; _x2++) {
          var u = _x2 / radialSegments
          var theta = u * thetaLength + thetaStart
          var cosTheta = Math.cos(theta)
          var 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 (var _x3 = 0; _x3 < radialSegments; _x3++) {
          var c = centerIndexStart + _x3
          var i = centerIndexEnd + _x3

          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
      }

      return _this
    }

    return CylinderBufferGeometry
  })(BufferGeometry)

  var CylinderGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(CylinderGeometry, _Geometry)

    function CylinderGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'CylinderGeometry'
      _this.parameters = {
        radiusTop: radiusTop,
        radiusBottom: radiusBottom,
        height: height,
        radialSegments: radialSegments,
        heightSegments: heightSegments,
        openEnded: openEnded,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }

      _this.fromBufferGeometry(new CylinderBufferGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength))

      _this.mergeVertices()

      return _this
    }

    return CylinderGeometry
  })(Geometry)

  var ConeGeometry = /*#__PURE__*/ (function (_CylinderGeometry) {
    _inheritsLoose(ConeGeometry, _CylinderGeometry)

    function ConeGeometry(radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
      var _this

      _this = _CylinderGeometry.call(this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) || this
      _this.type = 'ConeGeometry'
      _this.parameters = {
        radius: radius,
        height: height,
        radialSegments: radialSegments,
        heightSegments: heightSegments,
        openEnded: openEnded,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }
      return _this
    }

    return ConeGeometry
  })(CylinderGeometry)

  var ConeBufferGeometry = /*#__PURE__*/ (function (_CylinderBufferGeomet) {
    _inheritsLoose(ConeBufferGeometry, _CylinderBufferGeomet)

    function ConeBufferGeometry(radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (height === void 0) {
        height = 1
      }

      if (radialSegments === void 0) {
        radialSegments = 8
      }

      if (heightSegments === void 0) {
        heightSegments = 1
      }

      if (openEnded === void 0) {
        openEnded = false
      }

      if (thetaStart === void 0) {
        thetaStart = 0
      }

      if (thetaLength === void 0) {
        thetaLength = Math.PI * 2
      }

      _this = _CylinderBufferGeomet.call(this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength) || this
      _this.type = 'ConeBufferGeometry'
      _this.parameters = {
        radius: radius,
        height: height,
        radialSegments: radialSegments,
        heightSegments: heightSegments,
        openEnded: openEnded,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }
      return _this
    }

    return ConeBufferGeometry
  })(CylinderBufferGeometry)

  var PolyhedronBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(PolyhedronBufferGeometry, _BufferGeometry)

    function PolyhedronBufferGeometry(vertices, indices, radius, detail) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (detail === void 0) {
        detail = 0
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'PolyhedronBufferGeometry'
      _this.parameters = {
        vertices: vertices,
        indices: indices,
        radius: radius,
        detail: detail
      } // default buffer data

      var vertexBuffer = []
      var 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 Float32BufferAttribute(vertexBuffer, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(vertexBuffer.slice(), 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvBuffer, 2))

      if (detail === 0) {
        _this.computeVertexNormals() // flat normals
      } else {
        _this.normalizeNormals() // smooth normals
      } // helper functions

      function subdivide(detail) {
        var a = new Vector3()
        var b = new Vector3()
        var c = new Vector3() // iterate over all faces and apply a subdivison with the given detail value

        for (var 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) {
        var cols = detail + 1 // we use this multidimensional array as a data structure for creating the subdivision

        var v = [] // construct all of the vertices for this subdivision

        for (var i = 0; i <= cols; i++) {
          v[i] = []
          var aj = a.clone().lerp(c, i / cols)
          var bj = b.clone().lerp(c, i / cols)
          var rows = cols - i

          for (var 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 (var _i = 0; _i < cols; _i++) {
          for (var _j = 0; _j < 2 * (cols - _i) - 1; _j++) {
            var 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) {
        var vertex = new Vector3() // iterate over the entire buffer and apply the radius to each vertex

        for (var 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() {
        var vertex = new Vector3()

        for (var i = 0; i < vertexBuffer.length; i += 3) {
          vertex.x = vertexBuffer[i + 0]
          vertex.y = vertexBuffer[i + 1]
          vertex.z = vertexBuffer[i + 2]
          var u = azimuth(vertex) / 2 / Math.PI + 0.5
          var 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 (var i = 0; i < uvBuffer.length; i += 6) {
          // uv data of a single face
          var x0 = uvBuffer[i + 0]
          var x1 = uvBuffer[i + 2]
          var x2 = uvBuffer[i + 4]
          var max = Math.max(x0, x1, x2)
          var 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) {
        var stride = index * 3
        vertex.x = vertices[stride + 0]
        vertex.y = vertices[stride + 1]
        vertex.z = vertices[stride + 2]
      }

      function correctUVs() {
        var a = new Vector3()
        var b = new Vector3()
        var c = new Vector3()
        var centroid = new Vector3()
        var uvA = new Vector2()
        var uvB = new Vector2()
        var uvC = new Vector2()

        for (var 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)
          var 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))
      }

      return _this
    }

    return PolyhedronBufferGeometry
  })(BufferGeometry)

  var DodecahedronBufferGeometry = /*#__PURE__*/ (function (_PolyhedronBufferGeom) {
    _inheritsLoose(DodecahedronBufferGeometry, _PolyhedronBufferGeom)

    function DodecahedronBufferGeometry(radius, detail) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (detail === void 0) {
        detail = 0
      }

      var t = (1 + Math.sqrt(5)) / 2
      var r = 1 / t
      var 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
      ]
      var 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
      ]
      _this = _PolyhedronBufferGeom.call(this, vertices, indices, radius, detail) || this
      _this.type = 'DodecahedronBufferGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }
      return _this
    }

    return DodecahedronBufferGeometry
  })(PolyhedronBufferGeometry)

  var DodecahedronGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(DodecahedronGeometry, _Geometry)

    function DodecahedronGeometry(radius, detail) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'DodecahedronGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }

      _this.fromBufferGeometry(new DodecahedronBufferGeometry(radius, detail))

      _this.mergeVertices()

      return _this
    }

    return DodecahedronGeometry
  })(Geometry)

  var _v0$2 = new Vector3()

  var _v1$5 = new Vector3()

  var _normal$1 = new Vector3()

  var _triangle = new Triangle()

  var EdgesGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(EdgesGeometry, _BufferGeometry)

    function EdgesGeometry(geometry, thresholdAngle) {
      var _this

      _this = _BufferGeometry.call(this) || this
      _this.type = 'EdgesGeometry'
      _this.parameters = {
        thresholdAngle: thresholdAngle
      }
      thresholdAngle = thresholdAngle !== undefined ? thresholdAngle : 1

      if (geometry.isGeometry) {
        geometry = new BufferGeometry().fromGeometry(geometry)
      }

      var precisionPoints = 4
      var precision = Math.pow(10, precisionPoints)
      var thresholdDot = Math.cos(MathUtils.DEG2RAD * thresholdAngle)
      var indexAttr = geometry.getIndex()
      var positionAttr = geometry.getAttribute('position')
      var indexCount = indexAttr ? indexAttr.count : positionAttr.count
      var indexArr = [0, 0, 0]
      var vertKeys = ['a', 'b', 'c']
      var hashes = new Array(3)
      var edgeData = {}
      var vertices = []

      for (var 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
        }

        var a = _triangle.a,
          b = _triangle.b,
          c = _triangle.c
        a.fromBufferAttribute(positionAttr, indexArr[0])
        b.fromBufferAttribute(positionAttr, indexArr[1])
        c.fromBufferAttribute(positionAttr, indexArr[2])

        _triangle.getNormal(_normal$1) // 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 (var j = 0; j < 3; j++) {
          // get the first and next vertex making up the edge
          var jNext = (j + 1) % 3
          var vecHash0 = hashes[j]
          var vecHash1 = hashes[jNext]
          var v0 = _triangle[vertKeys[j]]
          var v1 = _triangle[vertKeys[jNext]]
          var hash = vecHash0 + '_' + vecHash1
          var 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 (_normal$1.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: _normal$1.clone()
            }
          }
        }
      } // iterate over all remaining, unmatched edges and add them to the vertex array

      for (var key in edgeData) {
        if (edgeData[key]) {
          var _edgeData$key = edgeData[key],
            index0 = _edgeData$key.index0,
            index1 = _edgeData$key.index1

          _v0$2.fromBufferAttribute(positionAttr, index0)

          _v1$5.fromBufferAttribute(positionAttr, index1)

          vertices.push(_v0$2.x, _v0$2.y, _v0$2.z)
          vertices.push(_v1$5.x, _v1$5.y, _v1$5.z)
        }
      }

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      return _this
    }

    return EdgesGeometry
  })(BufferGeometry)

  /**
   * Port from https://github.com/mapbox/earcut (v2.2.2)
   */
  var Earcut = {
    triangulate: function triangulate(data, holeIndices, dim) {
      dim = dim || 2
      var hasHoles = holeIndices && holeIndices.length
      var outerLen = hasHoles ? holeIndices[0] * dim : data.length
      var outerNode = linkedList(data, 0, outerLen, dim, true)
      var triangles = []
      if (!outerNode || outerNode.next === outerNode.prev) return triangles
      var minX, minY, maxX, maxY, x, y, invSize
      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim) // if 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 (var 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 ? 1 / invSize : 0
      }

      earcutLinked(outerNode, triangles, dim, minX, minY, invSize)
      return triangles
    }
  } // create a circular doubly linked list from polygon points in the specified winding order

  function linkedList(data, start, end, dim, clockwise) {
    var i, last

    if (clockwise === signedArea(data, start, end, dim) > 0) {
      for (i = start; i < end; i += dim) {
        last = insertNode(i, data[i], data[i + 1], last)
      }
    } else {
      for (i = end - dim; i >= start; i -= dim) {
        last = insertNode(i, data[i], data[i + 1], last)
      }
    }

    if (last && equals(last, last.next)) {
      removeNode(last)
      last = last.next
    }

    return last
  } // eliminate colinear or duplicate points

  function filterPoints(start, end) {
    if (!start) return start
    if (!end) end = start
    var p = start,
      again

    do {
      again = false

      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
        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 earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
    if (!ear) return // interlink polygon nodes in z-order

    if (!pass && invSize) indexCurve(ear, minX, minY, invSize)
    var 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 ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
        // cut off the triangle
        triangles.push(prev.i / dim)
        triangles.push(ear.i / dim)
        triangles.push(next.i / dim)
        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) {
          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1) // if this didn't work, try curing all small self-intersections locally
        } else if (pass === 1) {
          ear = cureLocalIntersections(filterPoints(ear), triangles, dim)
          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2) // as a last resort, try splitting the remaining polygon into two
        } else if (pass === 2) {
          splitEarcut(ear, triangles, dim, minX, minY, invSize)
        }

        break
      }
    }
  } // check whether a polygon node forms a valid ear with adjacent nodes

  function isEar(ear) {
    var a = ear.prev,
      b = ear,
      c = ear.next
    if (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

    var p = ear.next.next

    while (p !== ear.prev) {
      if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false
      p = p.next
    }

    return true
  }

  function isEarHashed(ear, minX, minY, invSize) {
    var a = ear.prev,
      b = ear,
      c = ear.next
    if (area(a, b, c) >= 0) return false // reflex, can't be an ear
    // triangle bbox; min & max are calculated like this for speed

    var minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : b.x < c.x ? b.x : c.x,
      minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : b.y < c.y ? b.y : c.y,
      maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : b.x > c.x ? b.x : c.x,
      maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : b.y > c.y ? b.y : c.y // z-order range for the current triangle bbox;

    var minZ = zOrder(minTX, minTY, minX, minY, invSize),
      maxZ = zOrder(maxTX, maxTY, minX, minY, invSize)
    var 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 !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false
      p = p.prevZ
      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && 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 !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && 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 !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && 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 cureLocalIntersections(start, triangles, dim) {
    var p = start

    do {
      var a = p.prev,
        b = p.next.next

      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
        triangles.push(a.i / dim)
        triangles.push(p.i / dim)
        triangles.push(b.i / dim) // remove two nodes involved

        removeNode(p)
        removeNode(p.next)
        p = start = b
      }

      p = p.next
    } while (p !== start)

    return filterPoints(p)
  } // try splitting polygon into two and triangulate them independently

  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
    // look for a valid diagonal that divides the polygon into two
    var a = start

    do {
      var b = a.next.next

      while (b !== a.prev) {
        if (a.i !== b.i && isValidDiagonal(a, b)) {
          // split the polygon in two by the diagonal
          var c = splitPolygon(a, b) // filter colinear points around the cuts

          a = filterPoints(a, a.next)
          c = filterPoints(c, c.next) // run earcut on each half

          earcutLinked(a, triangles, dim, minX, minY, invSize)
          earcutLinked(c, triangles, dim, minX, minY, invSize)
          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 eliminateHoles(data, holeIndices, outerNode, dim) {
    var queue = []
    var 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 = linkedList(data, start, end, dim, false)
      if (list === list.next) list.steiner = true
      queue.push(getLeftmost(list))
    }

    queue.sort(compareX) // process holes from left to right

    for (i = 0; i < queue.length; i++) {
      eliminateHole(queue[i], outerNode)
      outerNode = filterPoints(outerNode, outerNode.next)
    }

    return outerNode
  }

  function compareX(a, b) {
    return a.x - b.x
  } // find a bridge between vertices that connects hole with an outer ring and and link it

  function eliminateHole(hole, outerNode) {
    outerNode = findHoleBridge(hole, outerNode)

    if (outerNode) {
      var b = splitPolygon(outerNode, hole) // filter collinear points around the cuts

      filterPoints(outerNode, outerNode.next)
      filterPoints(b, b.next)
    }
  } // David Eberly's algorithm for finding a bridge between hole and outer polygon

  function findHoleBridge(hole, outerNode) {
    var p = outerNode
    var hx = hole.x
    var hy = hole.y
    var qx = -Infinity,
      m // 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) {
        var x = p.x + ((hy - p.y) * (p.next.x - p.x)) / (p.next.y - p.y)

        if (x <= hx && x > qx) {
          qx = x

          if (x === hx) {
            if (hy === p.y) return p
            if (hy === p.next.y) return p.next
          }

          m = p.x < p.next.x ? p : p.next
        }
      }

      p = p.next
    } while (p !== outerNode)

    if (!m) return null
    if (hx === qx) return m // hole touches outer segment; pick leftmost endpoint
    // 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

    var stop = m,
      mx = m.x,
      my = m.y
    var tanMin = Infinity,
      tan
    p = m

    do {
      if (hx >= p.x && p.x >= mx && hx !== p.x && 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 (locallyInside(p, hole) && (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && 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 sectorContainsSector(m, p) {
    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0
  } // interlink polygon nodes in z-order

  function indexCurve(start, minX, minY, invSize) {
    var p = start

    do {
      if (p.z === null) p.z = 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
    sortLinked(p)
  } // Simon Tatham's linked list merge sort algorithm
  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html

  function sortLinked(list) {
    var 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 zOrder(x, y, minX, minY, invSize) {
    // coords are transformed into non-negative 15-bit integer range
    x = 32767 * (x - minX) * invSize
    y = 32767 * (y - minY) * invSize
    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 getLeftmost(start) {
    var 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 pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0
  } // check if a diagonal between two polygon nodes is valid (lies in polygon interior)

  function isValidDiagonal(a, b) {
    return (
      a.next.i !== b.i &&
      a.prev.i !== b.i &&
      !intersectsPolygon(a, b) && // dones't intersect other edges
      ((locallyInside(a, b) &&
        locallyInside(b, a) &&
        middleInside(a, b) && // locally visible
        (area(a.prev, a, b.prev) || area(a, b.prev, b))) || // does not create opposite-facing sectors
        (equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0))
    ) // special zero-length case
  } // signed area of a triangle

  function 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 equals(p1, p2) {
    return p1.x === p2.x && p1.y === p2.y
  } // check if two segments intersect

  function intersects(p1, q1, p2, q2) {
    var o1 = sign(area(p1, q1, p2))
    var o2 = sign(area(p1, q1, q2))
    var o3 = sign(area(p2, q2, p1))
    var o4 = sign(area(p2, q2, q1))
    if (o1 !== o2 && o3 !== o4) return true // general case

    if (o1 === 0 && onSegment(p1, p2, q1)) return true // p1, q1 and p2 are collinear and p2 lies on p1q1

    if (o2 === 0 && onSegment(p1, q2, q1)) return true // p1, q1 and q2 are collinear and q2 lies on p1q1

    if (o3 === 0 && onSegment(p2, p1, q2)) return true // p2, q2 and p1 are collinear and p1 lies on p2q2

    if (o4 === 0 && 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 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 sign(num) {
    return num > 0 ? 1 : num < 0 ? -1 : 0
  } // check if a polygon diagonal intersects any polygon segments

  function intersectsPolygon(a, b) {
    var p = a

    do {
      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && 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 locallyInside(a, b) {
    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0
  } // check if the middle point of a polygon diagonal is inside the polygon

  function middleInside(a, b) {
    var p = a,
      inside = false
    var 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 splitPolygon(a, b) {
    var a2 = new Node(a.i, a.x, a.y),
      b2 = new 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 insertNode(i, x, y, last) {
    var p = new 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 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 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 = null // previous and next nodes in z-order

    this.prevZ = null
    this.nextZ = null // indicates whether this is a steiner point

    this.steiner = false
  }

  function signedArea(data, start, end, dim) {
    var sum = 0

    for (var i = start, j = end - dim; i < end; i += dim) {
      sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1])
      j = i
    }

    return sum
  }

  var ShapeUtils = {
    // calculate area of the contour polygon
    area: function area(contour) {
      var n = contour.length
      var a = 0.0

      for (var 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
    },
    isClockWise: function isClockWise(pts) {
      return ShapeUtils.area(pts) < 0
    },
    triangulateShape: function triangulateShape(contour, holes) {
      var vertices = [] // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]

      var holeIndices = [] // array of hole indices

      var faces = [] // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]

      removeDupEndPts(contour)
      addContour(vertices, contour) //

      var holeIndex = contour.length
      holes.forEach(removeDupEndPts)

      for (var i = 0; i < holes.length; i++) {
        holeIndices.push(holeIndex)
        holeIndex += holes[i].length
        addContour(vertices, holes[i])
      } //

      var triangles = Earcut.triangulate(vertices, holeIndices) //

      for (var _i = 0; _i < triangles.length; _i += 3) {
        faces.push(triangles.slice(_i, _i + 3))
      }

      return faces
    }
  }

  function removeDupEndPts(points) {
    var l = points.length

    if (l > 2 && points[l - 1].equals(points[0])) {
      points.pop()
    }
  }

  function addContour(vertices, contour) {
    for (var i = 0; i < contour.length; i++) {
      vertices.push(contour[i].x)
      vertices.push(contour[i].y)
    }
  }

  var ExtrudeBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(ExtrudeBufferGeometry, _BufferGeometry)

    function ExtrudeBufferGeometry(shapes, options) {
      var _this

      _this = _BufferGeometry.call(this) || this
      _this.type = 'ExtrudeBufferGeometry'
      _this.parameters = {
        shapes: shapes,
        options: options
      }
      shapes = Array.isArray(shapes) ? shapes : [shapes]

      var scope = _assertThisInitialized(_this)

      var verticesArray = []
      var uvArray = []

      for (var i = 0, l = shapes.length; i < l; i++) {
        var shape = shapes[i]
        addShape(shape)
      } // build geometry

      _this.setAttribute('position', new Float32BufferAttribute(verticesArray, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvArray, 2))

      _this.computeVertexNormals() // functions

      function addShape(shape) {
        var placeholder = [] // options

        var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12
        var steps = options.steps !== undefined ? options.steps : 1
        var depth = options.depth !== undefined ? options.depth : 100
        var bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true
        var bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6
        var bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2
        var bevelOffset = options.bevelOffset !== undefined ? options.bevelOffset : 0
        var bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3
        var extrudePath = options.extrudePath
        var uvgen = options.UVGenerator !== undefined ? options.UVGenerator : WorldUVGenerator // deprecated options

        if (options.amount !== undefined) {
          console.warn('THREE.ExtrudeBufferGeometry: amount has been renamed to depth.')
          depth = options.amount
        } //

        var extrudePts,
          extrudeByPath = false
        var 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 Vector3()
          normal = new Vector3()
          position2 = new Vector3()
        } // Safeguards if bevels are not enabled

        if (!bevelEnabled) {
          bevelSegments = 0
          bevelThickness = 0
          bevelSize = 0
          bevelOffset = 0
        } // Variables initialization

        var shapePoints = shape.extractPoints(curveSegments)
        var vertices = shapePoints.shape
        var holes = shapePoints.holes
        var reverse = !ShapeUtils.isClockWise(vertices)

        if (reverse) {
          vertices = vertices.reverse() // Maybe we should also check if holes are in the opposite direction, just to be safe ...

          for (var h = 0, hl = holes.length; h < hl; h++) {
            var ahole = holes[h]

            if (ShapeUtils.isClockWise(ahole)) {
              holes[h] = ahole.reverse()
            }
          }
        }

        var faces = ShapeUtils.triangulateShape(vertices, holes)
        /* Vertices */

        var contour = vertices // vertices has all points but contour has only points of circumference

        for (var _h = 0, _hl = holes.length; _h < _hl; _h++) {
          var _ahole = holes[_h]
          vertices = vertices.concat(_ahole)
        }

        function scalePt2(pt, vec, size) {
          if (!vec) console.error('THREE.ExtrudeGeometry: vec does not exist')
          return vec.clone().multiplyScalar(size).add(pt)
        }

        var 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.
          var 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

          var v_prev_x = inPt.x - inPrev.x,
            v_prev_y = inPt.y - inPrev.y
          var v_next_x = inNext.x - inPt.x,
            v_next_y = inNext.y - inPt.y
          var v_prev_lensq = v_prev_x * v_prev_x + v_prev_y * v_prev_y // check for collinear edges

          var 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
            var v_prev_len = Math.sqrt(v_prev_lensq)
            var 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

            var ptPrevShift_x = inPrev.x - v_prev_y / v_prev_len
            var ptPrevShift_y = inPrev.y + v_prev_x / v_prev_len
            var ptNextShift_x = inNext.x - v_next_y / v_next_len
            var ptNextShift_y = inNext.y + v_next_x / v_next_len // scaling factor for v_prev to intersection point

            var 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

            var v_trans_lensq = v_trans_x * v_trans_x + v_trans_y * v_trans_y

            if (v_trans_lensq <= 2) {
              return new Vector2(v_trans_x, v_trans_y)
            } else {
              shrink_by = Math.sqrt(v_trans_lensq / 2)
            }
          } else {
            // handle special case of collinear edges
            var 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 Vector2(v_trans_x / shrink_by, v_trans_y / shrink_by)
        }

        var contourMovements = []

        for (var _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])
        }

        var holesMovements = []
        var oneHoleMovements,
          verticesMovements = contourMovements.concat()

        for (var _h2 = 0, _hl2 = holes.length; _h2 < _hl2; _h2++) {
          var _ahole2 = holes[_h2]
          oneHoleMovements = []

          for (var _i2 = 0, _il = _ahole2.length, _j = _il - 1, _k = _i2 + 1; _i2 < _il; _i2++, _j++, _k++) {
            if (_j === _il) _j = 0
            if (_k === _il) _k = 0 //	(j)---(i)---(k)

            oneHoleMovements[_i2] = getBevelVec(_ahole2[_i2], _ahole2[_j], _ahole2[_k])
          }

          holesMovements.push(oneHoleMovements)
          verticesMovements = verticesMovements.concat(oneHoleMovements)
        } // Loop bevelSegments, 1 for the front, 1 for the back

        for (var b = 0; b < bevelSegments; b++) {
          //for ( b = bevelSegments; b > 0; b -- ) {
          var t = b / bevelSegments
          var z = bevelThickness * Math.cos((t * Math.PI) / 2)

          var _bs = bevelSize * Math.sin((t * Math.PI) / 2) + bevelOffset // contract shape

          for (var _i3 = 0, _il2 = contour.length; _i3 < _il2; _i3++) {
            var vert = scalePt2(contour[_i3], contourMovements[_i3], _bs)
            v(vert.x, vert.y, -z)
          } // expand holes

          for (var _h3 = 0, _hl3 = holes.length; _h3 < _hl3; _h3++) {
            var _ahole3 = holes[_h3]
            oneHoleMovements = holesMovements[_h3]

            for (var _i4 = 0, _il3 = _ahole3.length; _i4 < _il3; _i4++) {
              var _vert = scalePt2(_ahole3[_i4], oneHoleMovements[_i4], _bs)

              v(_vert.x, _vert.y, -z)
            }
          }
        }

        var bs = bevelSize + bevelOffset // Back facing vertices

        for (var _i5 = 0; _i5 < vlen; _i5++) {
          var _vert2 = bevelEnabled ? scalePt2(vertices[_i5], verticesMovements[_i5], bs) : vertices[_i5]

          if (!extrudeByPath) {
            v(_vert2.x, _vert2.y, 0)
          } else {
            // v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );
            normal.copy(splineTube.normals[0]).multiplyScalar(_vert2.x)
            binormal.copy(splineTube.binormals[0]).multiplyScalar(_vert2.y)
            position2.copy(extrudePts[0]).add(normal).add(binormal)
            v(position2.x, position2.y, position2.z)
          }
        } // Add stepped vertices...
        // Including front facing vertices

        for (var s = 1; s <= steps; s++) {
          for (var _i6 = 0; _i6 < vlen; _i6++) {
            var _vert3 = bevelEnabled ? scalePt2(vertices[_i6], verticesMovements[_i6], bs) : vertices[_i6]

            if (!extrudeByPath) {
              v(_vert3.x, _vert3.y, (depth / steps) * s)
            } else {
              // v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );
              normal.copy(splineTube.normals[s]).multiplyScalar(_vert3.x)
              binormal.copy(splineTube.binormals[s]).multiplyScalar(_vert3.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 (var _b = bevelSegments - 1; _b >= 0; _b--) {
          var _t = _b / bevelSegments

          var _z = bevelThickness * Math.cos((_t * Math.PI) / 2)

          var _bs2 = bevelSize * Math.sin((_t * Math.PI) / 2) + bevelOffset // contract shape

          for (var _i7 = 0, _il4 = contour.length; _i7 < _il4; _i7++) {
            var _vert4 = scalePt2(contour[_i7], contourMovements[_i7], _bs2)

            v(_vert4.x, _vert4.y, depth + _z)
          } // expand holes

          for (var _h4 = 0, _hl4 = holes.length; _h4 < _hl4; _h4++) {
            var _ahole4 = holes[_h4]
            oneHoleMovements = holesMovements[_h4]

            for (var _i8 = 0, _il5 = _ahole4.length; _i8 < _il5; _i8++) {
              var _vert5 = scalePt2(_ahole4[_i8], oneHoleMovements[_i8], _bs2)

              if (!extrudeByPath) {
                v(_vert5.x, _vert5.y, depth + _z)
              } else {
                v(_vert5.x, _vert5.y + extrudePts[steps - 1].y, extrudePts[steps - 1].x + _z)
              }
            }
          }
        }
        /* Faces */
        // Top and bottom faces

        buildLidFaces() // Sides faces

        buildSideFaces() /////	Internal functions

        function buildLidFaces() {
          var start = verticesArray.length / 3

          if (bevelEnabled) {
            var layer = 0 // steps + 1

            var offset = vlen * layer // Bottom faces

            for (var _i9 = 0; _i9 < flen; _i9++) {
              var face = faces[_i9]
              f3(face[2] + offset, face[1] + offset, face[0] + offset)
            }

            layer = steps + bevelSegments * 2
            offset = vlen * layer // Top faces

            for (var _i10 = 0; _i10 < flen; _i10++) {
              var _face = faces[_i10]
              f3(_face[0] + offset, _face[1] + offset, _face[2] + offset)
            }
          } else {
            // Bottom faces
            for (var _i11 = 0; _i11 < flen; _i11++) {
              var _face2 = faces[_i11]
              f3(_face2[2], _face2[1], _face2[0])
            } // Top faces

            for (var _i12 = 0; _i12 < flen; _i12++) {
              var _face3 = faces[_i12]
              f3(_face3[0] + vlen * steps, _face3[1] + vlen * steps, _face3[2] + vlen * steps)
            }
          }

          scope.addGroup(start, verticesArray.length / 3 - start, 0)
        } // Create faces for the z-sides of the shape

        function buildSideFaces() {
          var start = verticesArray.length / 3
          var layeroffset = 0
          sidewalls(contour, layeroffset)
          layeroffset += contour.length

          for (var _h5 = 0, _hl5 = holes.length; _h5 < _hl5; _h5++) {
            var _ahole5 = holes[_h5]
            sidewalls(_ahole5, layeroffset) //, true

            layeroffset += _ahole5.length
          }

          scope.addGroup(start, verticesArray.length / 3 - start, 1)
        }

        function sidewalls(contour, layeroffset) {
          var i = contour.length

          while (--i >= 0) {
            var _j2 = i

            var _k2 = i - 1

            if (_k2 < 0) _k2 = contour.length - 1 //console.log('b', i,j, i-1, k,vertices.length);

            for (var _s = 0, sl = steps + bevelSegments * 2; _s < sl; _s++) {
              var slen1 = vlen * _s
              var slen2 = vlen * (_s + 1)

              var a = layeroffset + _j2 + slen1,
                _b2 = layeroffset + _k2 + slen1,
                c = layeroffset + _k2 + slen2,
                d = layeroffset + _j2 + slen2

              f4(a, _b2, 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)
          var nextIndex = verticesArray.length / 3
          var 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)
          var nextIndex = verticesArray.length / 3
          var 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)
        }
      }

      return _this
    }

    var _proto = ExtrudeBufferGeometry.prototype

    _proto.toJSON = function toJSON() {
      var data = BufferGeometry.prototype.toJSON.call(this)
      var shapes = this.parameters.shapes
      var options = this.parameters.options
      return _toJSON(shapes, options, data)
    }

    return ExtrudeBufferGeometry
  })(BufferGeometry)

  var WorldUVGenerator = {
    generateTopUV: function generateTopUV(geometry, vertices, indexA, indexB, indexC) {
      var a_x = vertices[indexA * 3]
      var a_y = vertices[indexA * 3 + 1]
      var b_x = vertices[indexB * 3]
      var b_y = vertices[indexB * 3 + 1]
      var c_x = vertices[indexC * 3]
      var c_y = vertices[indexC * 3 + 1]
      return [new Vector2(a_x, a_y), new Vector2(b_x, b_y), new Vector2(c_x, c_y)]
    },
    generateSideWallUV: function generateSideWallUV(geometry, vertices, indexA, indexB, indexC, indexD) {
      var a_x = vertices[indexA * 3]
      var a_y = vertices[indexA * 3 + 1]
      var a_z = vertices[indexA * 3 + 2]
      var b_x = vertices[indexB * 3]
      var b_y = vertices[indexB * 3 + 1]
      var b_z = vertices[indexB * 3 + 2]
      var c_x = vertices[indexC * 3]
      var c_y = vertices[indexC * 3 + 1]
      var c_z = vertices[indexC * 3 + 2]
      var d_x = vertices[indexD * 3]
      var d_y = vertices[indexD * 3 + 1]
      var d_z = vertices[indexD * 3 + 2]

      if (Math.abs(a_y - b_y) < 0.01) {
        return [new Vector2(a_x, 1 - a_z), new Vector2(b_x, 1 - b_z), new Vector2(c_x, 1 - c_z), new Vector2(d_x, 1 - d_z)]
      } else {
        return [new Vector2(a_y, 1 - a_z), new Vector2(b_y, 1 - b_z), new Vector2(c_y, 1 - c_z), new Vector2(d_y, 1 - d_z)]
      }
    }
  }

  function _toJSON(shapes, options, data) {
    data.shapes = []

    if (Array.isArray(shapes)) {
      for (var i = 0, l = shapes.length; i < l; i++) {
        var shape = shapes[i]
        data.shapes.push(shape.uuid)
      }
    } else {
      data.shapes.push(shapes.uuid)
    }

    if (options.extrudePath !== undefined) data.options.extrudePath = options.extrudePath.toJSON()
    return data
  }

  var ExtrudeGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(ExtrudeGeometry, _Geometry)

    function ExtrudeGeometry(shapes, options) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'ExtrudeGeometry'
      _this.parameters = {
        shapes: shapes,
        options: options
      }

      _this.fromBufferGeometry(new ExtrudeBufferGeometry(shapes, options))

      _this.mergeVertices()

      return _this
    }

    var _proto = ExtrudeGeometry.prototype

    _proto.toJSON = function toJSON() {
      var data = _Geometry.prototype.toJSON.call(this)

      var shapes = this.parameters.shapes
      var options = this.parameters.options
      return _toJSON$1(shapes, options, data)
    }

    return ExtrudeGeometry
  })(Geometry)

  function _toJSON$1(shapes, options, data) {
    data.shapes = []

    if (Array.isArray(shapes)) {
      for (var i = 0, l = shapes.length; i < l; i++) {
        var shape = shapes[i]
        data.shapes.push(shape.uuid)
      }
    } else {
      data.shapes.push(shapes.uuid)
    }

    if (options.extrudePath !== undefined) data.options.extrudePath = options.extrudePath.toJSON()
    return data
  }

  var IcosahedronBufferGeometry = /*#__PURE__*/ (function (_PolyhedronBufferGeom) {
    _inheritsLoose(IcosahedronBufferGeometry, _PolyhedronBufferGeom)

    function IcosahedronBufferGeometry(radius, detail) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (detail === void 0) {
        detail = 0
      }

      var t = (1 + Math.sqrt(5)) / 2
      var 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]
      var 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
      ]
      _this = _PolyhedronBufferGeom.call(this, vertices, indices, radius, detail) || this
      _this.type = 'IcosahedronBufferGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }
      return _this
    }

    return IcosahedronBufferGeometry
  })(PolyhedronBufferGeometry)

  var IcosahedronGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(IcosahedronGeometry, _Geometry)

    function IcosahedronGeometry(radius, detail) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'IcosahedronGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }

      _this.fromBufferGeometry(new IcosahedronBufferGeometry(radius, detail))

      _this.mergeVertices()

      return _this
    }

    return IcosahedronGeometry
  })(Geometry)

  var LatheBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(LatheBufferGeometry, _BufferGeometry)

    function LatheBufferGeometry(points, segments, phiStart, phiLength) {
      var _this

      if (segments === void 0) {
        segments = 12
      }

      if (phiStart === void 0) {
        phiStart = 0
      }

      if (phiLength === void 0) {
        phiLength = Math.PI * 2
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'LatheBufferGeometry'
      _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 = MathUtils.clamp(phiLength, 0, Math.PI * 2) // buffers

      var indices = []
      var vertices = []
      var uvs = [] // helper variables

      var inverseSegments = 1.0 / segments
      var vertex = new Vector3()
      var uv = new Vector2() // generate vertices and uvs

      for (var i = 0; i <= segments; i++) {
        var phi = phiStart + i * inverseSegments * phiLength
        var sin = Math.sin(phi)
        var cos = Math.cos(phi)

        for (var 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)
        }
      } // indices

      for (var _i = 0; _i < segments; _i++) {
        for (var _j = 0; _j < points.length - 1; _j++) {
          var base = _j + _i * points.length
          var a = base
          var b = base + points.length
          var c = base + points.length + 1
          var d = base + 1 // faces

          indices.push(a, b, d)
          indices.push(b, c, d)
        }
      } // build geometry

      _this.setIndex(indices)

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2)) // generate normals

      _this.computeVertexNormals() // if the geometry is closed, we need to average the normals along the seam.
      // because the corresponding vertices are identical (but still have different UVs).

      if (phiLength === Math.PI * 2) {
        var normals = _this.attributes.normal.array
        var n1 = new Vector3()
        var n2 = new Vector3()
        var n = new Vector3() // this is the buffer offset for the last line of vertices

        var _base = segments * points.length * 3

        for (var _i2 = 0, _j2 = 0; _i2 < points.length; _i2++, _j2 += 3) {
          // select the normal of the vertex in the first line
          n1.x = normals[_j2 + 0]
          n1.y = normals[_j2 + 1]
          n1.z = normals[_j2 + 2] // select the normal of the vertex in the last line

          n2.x = normals[_base + _j2 + 0]
          n2.y = normals[_base + _j2 + 1]
          n2.z = normals[_base + _j2 + 2] // average normals

          n.addVectors(n1, n2).normalize() // assign the new values to both normals

          normals[_j2 + 0] = normals[_base + _j2 + 0] = n.x
          normals[_j2 + 1] = normals[_base + _j2 + 1] = n.y
          normals[_j2 + 2] = normals[_base + _j2 + 2] = n.z
        }
      }

      return _this
    }

    return LatheBufferGeometry
  })(BufferGeometry)

  var LatheGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(LatheGeometry, _Geometry)

    function LatheGeometry(points, segments, phiStart, phiLength) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'LatheGeometry'
      _this.parameters = {
        points: points,
        segments: segments,
        phiStart: phiStart,
        phiLength: phiLength
      }

      _this.fromBufferGeometry(new LatheBufferGeometry(points, segments, phiStart, phiLength))

      _this.mergeVertices()

      return _this
    }

    return LatheGeometry
  })(Geometry)

  var OctahedronBufferGeometry = /*#__PURE__*/ (function (_PolyhedronBufferGeom) {
    _inheritsLoose(OctahedronBufferGeometry, _PolyhedronBufferGeom)

    function OctahedronBufferGeometry(radius, detail) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (detail === void 0) {
        detail = 0
      }

      var vertices = [1, 0, 0, -1, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 1, 0, 0, -1]
      var 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]
      _this = _PolyhedronBufferGeom.call(this, vertices, indices, radius, detail) || this
      _this.type = 'OctahedronBufferGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }
      return _this
    }

    return OctahedronBufferGeometry
  })(PolyhedronBufferGeometry)

  var OctahedronGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(OctahedronGeometry, _Geometry)

    function OctahedronGeometry(radius, detail) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'OctahedronGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }

      _this.fromBufferGeometry(new OctahedronBufferGeometry(radius, detail))

      _this.mergeVertices()

      return _this
    }

    return OctahedronGeometry
  })(Geometry)

  /**
   * Parametric Surfaces Geometry
   * based on the brilliant article by @prideout https://prideout.net/blog/old/blog/index.html@p=44.html
   */

  function ParametricBufferGeometry(func, slices, stacks) {
    BufferGeometry.call(this)
    this.type = 'ParametricBufferGeometry'
    this.parameters = {
      func: func,
      slices: slices,
      stacks: stacks
    } // buffers

    var indices = []
    var vertices = []
    var normals = []
    var uvs = []
    var EPS = 0.00001
    var normal = new Vector3()
    var p0 = new Vector3(),
      p1 = new Vector3()
    var pu = new Vector3(),
      pv = new Vector3()

    if (func.length < 3) {
      console.error('THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.')
    } // generate vertices, normals and uvs

    var sliceCount = slices + 1

    for (var i = 0; i <= stacks; i++) {
      var v = i / stacks

      for (var j = 0; j <= slices; j++) {
        var u = j / slices // vertex

        func(u, v, p0)
        vertices.push(p0.x, p0.y, p0.z) // normal
        // approximate tangent vectors via finite differences

        if (u - EPS >= 0) {
          func(u - EPS, v, p1)
          pu.subVectors(p0, p1)
        } else {
          func(u + EPS, v, p1)
          pu.subVectors(p1, p0)
        }

        if (v - EPS >= 0) {
          func(u, v - EPS, p1)
          pv.subVectors(p0, p1)
        } else {
          func(u, v + EPS, p1)
          pv.subVectors(p1, p0)
        } // cross product of tangent vectors returns surface normal

        normal.crossVectors(pu, pv).normalize()
        normals.push(normal.x, normal.y, normal.z) // uv

        uvs.push(u, v)
      }
    } // generate indices

    for (var _i = 0; _i < stacks; _i++) {
      for (var _j = 0; _j < slices; _j++) {
        var a = _i * sliceCount + _j
        var b = _i * sliceCount + _j + 1
        var c = (_i + 1) * sliceCount + _j + 1
        var d = (_i + 1) * sliceCount + _j // faces one and two

        indices.push(a, b, d)
        indices.push(b, c, d)
      }
    } // build geometry

    this.setIndex(indices)
    this.setAttribute('position', new Float32BufferAttribute(vertices, 3))
    this.setAttribute('normal', new Float32BufferAttribute(normals, 3))
    this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))
  }

  ParametricBufferGeometry.prototype = Object.create(BufferGeometry.prototype)
  ParametricBufferGeometry.prototype.constructor = ParametricBufferGeometry

  /**
   * Parametric Surfaces Geometry
   * based on the brilliant article by @prideout https://prideout.net/blog/old/blog/index.html@p=44.html
   */

  function ParametricGeometry(func, slices, stacks) {
    Geometry.call(this)
    this.type = 'ParametricGeometry'
    this.parameters = {
      func: func,
      slices: slices,
      stacks: stacks
    }
    this.fromBufferGeometry(new ParametricBufferGeometry(func, slices, stacks))
    this.mergeVertices()
  }

  ParametricGeometry.prototype = Object.create(Geometry.prototype)
  ParametricGeometry.prototype.constructor = ParametricGeometry

  var PlaneGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(PlaneGeometry, _Geometry)

    function PlaneGeometry(width, height, widthSegments, heightSegments) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'PlaneGeometry'
      _this.parameters = {
        width: width,
        height: height,
        widthSegments: widthSegments,
        heightSegments: heightSegments
      }

      _this.fromBufferGeometry(new PlaneBufferGeometry(width, height, widthSegments, heightSegments))

      _this.mergeVertices()

      return _this
    }

    return PlaneGeometry
  })(Geometry)

  var PolyhedronGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(PolyhedronGeometry, _Geometry)

    function PolyhedronGeometry(vertices, indices, radius, detail) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'PolyhedronGeometry'
      _this.parameters = {
        vertices: vertices,
        indices: indices,
        radius: radius,
        detail: detail
      }

      _this.fromBufferGeometry(new PolyhedronBufferGeometry(vertices, indices, radius, detail))

      _this.mergeVertices()

      return _this
    }

    return PolyhedronGeometry
  })(Geometry)

  var RingBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(RingBufferGeometry, _BufferGeometry)

    function RingBufferGeometry(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength) {
      var _this

      if (innerRadius === void 0) {
        innerRadius = 0.5
      }

      if (outerRadius === void 0) {
        outerRadius = 1
      }

      if (thetaSegments === void 0) {
        thetaSegments = 8
      }

      if (phiSegments === void 0) {
        phiSegments = 1
      }

      if (thetaStart === void 0) {
        thetaStart = 0
      }

      if (thetaLength === void 0) {
        thetaLength = Math.PI * 2
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'RingBufferGeometry'
      _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

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // some helper variables

      var radius = innerRadius
      var radiusStep = (outerRadius - innerRadius) / phiSegments
      var vertex = new Vector3()
      var uv = new Vector2() // generate vertices, normals and uvs

      for (var j = 0; j <= phiSegments; j++) {
        for (var i = 0; i <= thetaSegments; i++) {
          // values are generate from the inside of the ring to the outside
          var 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 (var _j = 0; _j < phiSegments; _j++) {
        var thetaSegmentLevel = _j * (thetaSegments + 1)

        for (var _i = 0; _i < thetaSegments; _i++) {
          var _segment = _i + thetaSegmentLevel

          var a = _segment
          var b = _segment + thetaSegments + 1
          var c = _segment + thetaSegments + 2
          var d = _segment + 1 // faces

          indices.push(a, b, d)
          indices.push(b, c, d)
        }
      } // build geometry

      _this.setIndex(indices)

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      return _this
    }

    return RingBufferGeometry
  })(BufferGeometry)

  var RingGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(RingGeometry, _Geometry)

    function RingGeometry(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'RingGeometry'
      _this.parameters = {
        innerRadius: innerRadius,
        outerRadius: outerRadius,
        thetaSegments: thetaSegments,
        phiSegments: phiSegments,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }

      _this.fromBufferGeometry(new RingBufferGeometry(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength))

      _this.mergeVertices()

      return _this
    }

    return RingGeometry
  })(Geometry)

  var ShapeBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(ShapeBufferGeometry, _BufferGeometry)

    function ShapeBufferGeometry(shapes, curveSegments) {
      var _this

      if (curveSegments === void 0) {
        curveSegments = 12
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'ShapeBufferGeometry'
      _this.parameters = {
        shapes: shapes,
        curveSegments: curveSegments
      } // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // helper variables

      var groupStart = 0
      var groupCount = 0 // allow single and array values for "shapes" parameter

      if (Array.isArray(shapes) === false) {
        addShape(shapes)
      } else {
        for (var 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 Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2)) // helper functions

      function addShape(shape) {
        var indexOffset = vertices.length / 3
        var points = shape.extractPoints(curveSegments)
        var shapeVertices = points.shape
        var shapeHoles = points.holes // check direction of vertices

        if (ShapeUtils.isClockWise(shapeVertices) === false) {
          shapeVertices = shapeVertices.reverse()
        }

        for (var _i = 0, l = shapeHoles.length; _i < l; _i++) {
          var shapeHole = shapeHoles[_i]

          if (ShapeUtils.isClockWise(shapeHole) === true) {
            shapeHoles[_i] = shapeHole.reverse()
          }
        }

        var faces = ShapeUtils.triangulateShape(shapeVertices, shapeHoles) // join vertices of inner and outer paths to a single array

        for (var _i2 = 0, _l = shapeHoles.length; _i2 < _l; _i2++) {
          var _shapeHole = shapeHoles[_i2]
          shapeVertices = shapeVertices.concat(_shapeHole)
        } // vertices, normals, uvs

        for (var _i3 = 0, _l2 = shapeVertices.length; _i3 < _l2; _i3++) {
          var vertex = shapeVertices[_i3]
          vertices.push(vertex.x, vertex.y, 0)
          normals.push(0, 0, 1)
          uvs.push(vertex.x, vertex.y) // world uvs
        } // incides

        for (var _i4 = 0, _l3 = faces.length; _i4 < _l3; _i4++) {
          var face = faces[_i4]
          var a = face[0] + indexOffset
          var b = face[1] + indexOffset
          var c = face[2] + indexOffset
          indices.push(a, b, c)
          groupCount += 3
        }
      }

      return _this
    }

    var _proto = ShapeBufferGeometry.prototype

    _proto.toJSON = function toJSON() {
      var data = BufferGeometry.prototype.toJSON.call(this)
      var shapes = this.parameters.shapes
      return _toJSON$2(shapes, data)
    }

    return ShapeBufferGeometry
  })(BufferGeometry)

  function _toJSON$2(shapes, data) {
    data.shapes = []

    if (Array.isArray(shapes)) {
      for (var i = 0, l = shapes.length; i < l; i++) {
        var shape = shapes[i]
        data.shapes.push(shape.uuid)
      }
    } else {
      data.shapes.push(shapes.uuid)
    }

    return data
  }

  var ShapeGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(ShapeGeometry, _Geometry)

    function ShapeGeometry(shapes, curveSegments) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'ShapeGeometry'

      if (typeof curveSegments === 'object') {
        console.warn('THREE.ShapeGeometry: Options parameter has been removed.')
        curveSegments = curveSegments.curveSegments
      }

      _this.parameters = {
        shapes: shapes,
        curveSegments: curveSegments
      }

      _this.fromBufferGeometry(new ShapeBufferGeometry(shapes, curveSegments))

      _this.mergeVertices()

      return _this
    }

    var _proto = ShapeGeometry.prototype

    _proto.toJSON = function toJSON() {
      var data = Geometry.prototype.toJSON.call(this)
      var shapes = this.parameters.shapes
      return _toJSON$3(shapes, data)
    }

    return ShapeGeometry
  })(Geometry)

  function _toJSON$3(shapes, data) {
    data.shapes = []

    if (Array.isArray(shapes)) {
      for (var i = 0, l = shapes.length; i < l; i++) {
        var shape = shapes[i]
        data.shapes.push(shape.uuid)
      }
    } else {
      data.shapes.push(shapes.uuid)
    }

    return data
  }

  var SphereBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(SphereBufferGeometry, _BufferGeometry)

    function SphereBufferGeometry(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (widthSegments === void 0) {
        widthSegments = 8
      }

      if (heightSegments === void 0) {
        heightSegments = 6
      }

      if (phiStart === void 0) {
        phiStart = 0
      }

      if (phiLength === void 0) {
        phiLength = Math.PI * 2
      }

      if (thetaStart === void 0) {
        thetaStart = 0
      }

      if (thetaLength === void 0) {
        thetaLength = Math.PI
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'SphereBufferGeometry'
      _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))
      var thetaEnd = Math.min(thetaStart + thetaLength, Math.PI)
      var index = 0
      var grid = []
      var vertex = new Vector3()
      var normal = new Vector3() // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // generate vertices, normals and uvs

      for (var iy = 0; iy <= heightSegments; iy++) {
        var verticesRow = []
        var v = iy / heightSegments // special case for the poles

        var uOffset = 0

        if (iy == 0 && thetaStart == 0) {
          uOffset = 0.5 / widthSegments
        } else if (iy == heightSegments && thetaEnd == Math.PI) {
          uOffset = -0.5 / widthSegments
        }

        for (var ix = 0; ix <= widthSegments; ix++) {
          var 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 (var _iy = 0; _iy < heightSegments; _iy++) {
        for (var _ix = 0; _ix < widthSegments; _ix++) {
          var a = grid[_iy][_ix + 1]
          var b = grid[_iy][_ix]
          var c = grid[_iy + 1][_ix]
          var 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 Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      return _this
    }

    return SphereBufferGeometry
  })(BufferGeometry)

  var SphereGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(SphereGeometry, _Geometry)

    function SphereGeometry(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'SphereGeometry'
      _this.parameters = {
        radius: radius,
        widthSegments: widthSegments,
        heightSegments: heightSegments,
        phiStart: phiStart,
        phiLength: phiLength,
        thetaStart: thetaStart,
        thetaLength: thetaLength
      }

      _this.fromBufferGeometry(new SphereBufferGeometry(radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength))

      _this.mergeVertices()

      return _this
    }

    return SphereGeometry
  })(Geometry)

  var TetrahedronBufferGeometry = /*#__PURE__*/ (function (_PolyhedronBufferGeom) {
    _inheritsLoose(TetrahedronBufferGeometry, _PolyhedronBufferGeom)

    function TetrahedronBufferGeometry(radius, detail) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (detail === void 0) {
        detail = 0
      }

      var vertices = [1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1, -1]
      var indices = [2, 1, 0, 0, 3, 2, 1, 3, 0, 2, 3, 1]
      _this = _PolyhedronBufferGeom.call(this, vertices, indices, radius, detail) || this
      _this.type = 'TetrahedronBufferGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }
      return _this
    }

    return TetrahedronBufferGeometry
  })(PolyhedronBufferGeometry)

  var TetrahedronGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(TetrahedronGeometry, _Geometry)

    function TetrahedronGeometry(radius, detail) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'TetrahedronGeometry'
      _this.parameters = {
        radius: radius,
        detail: detail
      }

      _this.fromBufferGeometry(new TetrahedronBufferGeometry(radius, detail))

      _this.mergeVertices()

      return _this
    }

    return TetrahedronGeometry
  })(Geometry)

  var TextBufferGeometry = /*#__PURE__*/ (function (_ExtrudeBufferGeometr) {
    _inheritsLoose(TextBufferGeometry, _ExtrudeBufferGeometr)

    function TextBufferGeometry(text, parameters) {
      var _this

      if (parameters === void 0) {
        parameters = {}
      }

      var font = parameters.font

      if (!(font && font.isFont)) {
        console.error('THREE.TextGeometry: font parameter is not an instance of THREE.Font.')
        return new BufferGeometry() || _assertThisInitialized(_this)
      }

      var shapes = font.generateShapes(text, parameters.size) // translate parameters to ExtrudeGeometry API

      parameters.depth = parameters.height !== undefined ? parameters.height : 50 // defaults

      if (parameters.bevelThickness === undefined) parameters.bevelThickness = 10
      if (parameters.bevelSize === undefined) parameters.bevelSize = 8
      if (parameters.bevelEnabled === undefined) parameters.bevelEnabled = false
      _this = _ExtrudeBufferGeometr.call(this, shapes, parameters) || this
      _this.type = 'TextBufferGeometry'
      return _this
    }

    return TextBufferGeometry
  })(ExtrudeBufferGeometry)

  var TextGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(TextGeometry, _Geometry)

    function TextGeometry(text, parameters) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'TextGeometry'
      _this.parameters = {
        text: text,
        parameters: parameters
      }

      _this.fromBufferGeometry(new TextBufferGeometry(text, parameters))

      _this.mergeVertices()

      return _this
    }

    return TextGeometry
  })(Geometry)

  var TorusBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(TorusBufferGeometry, _BufferGeometry)

    function TorusBufferGeometry(radius, tube, radialSegments, tubularSegments, arc) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (tube === void 0) {
        tube = 0.4
      }

      if (radialSegments === void 0) {
        radialSegments = 8
      }

      if (tubularSegments === void 0) {
        tubularSegments = 6
      }

      if (arc === void 0) {
        arc = Math.PI * 2
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'TorusBufferGeometry'
      _this.parameters = {
        radius: radius,
        tube: tube,
        radialSegments: radialSegments,
        tubularSegments: tubularSegments,
        arc: arc
      }
      radialSegments = Math.floor(radialSegments)
      tubularSegments = Math.floor(tubularSegments) // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // helper variables

      var center = new Vector3()
      var vertex = new Vector3()
      var normal = new Vector3() // generate vertices, normals and uvs

      for (var j = 0; j <= radialSegments; j++) {
        for (var i = 0; i <= tubularSegments; i++) {
          var u = (i / tubularSegments) * arc
          var 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 (var _j = 1; _j <= radialSegments; _j++) {
        for (var _i = 1; _i <= tubularSegments; _i++) {
          // indices
          var a = (tubularSegments + 1) * _j + _i - 1
          var b = (tubularSegments + 1) * (_j - 1) + _i - 1
          var c = (tubularSegments + 1) * (_j - 1) + _i
          var 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 Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2))

      return _this
    }

    return TorusBufferGeometry
  })(BufferGeometry)

  var TorusGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(TorusGeometry, _Geometry)

    function TorusGeometry(radius, tube, radialSegments, tubularSegments, arc) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'TorusGeometry'
      _this.parameters = {
        radius: radius,
        tube: tube,
        radialSegments: radialSegments,
        tubularSegments: tubularSegments,
        arc: arc
      }

      _this.fromBufferGeometry(new TorusBufferGeometry(radius, tube, radialSegments, tubularSegments, arc))

      _this.mergeVertices()

      return _this
    }

    return TorusGeometry
  })(Geometry)

  var TorusKnotBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(TorusKnotBufferGeometry, _BufferGeometry)

    function TorusKnotBufferGeometry(radius, tube, tubularSegments, radialSegments, p, q) {
      var _this

      if (radius === void 0) {
        radius = 1
      }

      if (tube === void 0) {
        tube = 0.4
      }

      if (tubularSegments === void 0) {
        tubularSegments = 64
      }

      if (radialSegments === void 0) {
        radialSegments = 8
      }

      if (p === void 0) {
        p = 2
      }

      if (q === void 0) {
        q = 3
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'TorusKnotBufferGeometry'
      _this.parameters = {
        radius: radius,
        tube: tube,
        tubularSegments: tubularSegments,
        radialSegments: radialSegments,
        p: p,
        q: q
      }
      tubularSegments = Math.floor(tubularSegments)
      radialSegments = Math.floor(radialSegments) // buffers

      var indices = []
      var vertices = []
      var normals = []
      var uvs = [] // helper variables

      var vertex = new Vector3()
      var normal = new Vector3()
      var P1 = new Vector3()
      var P2 = new Vector3()
      var B = new Vector3()
      var T = new Vector3()
      var N = new Vector3() // generate vertices, normals and uvs

      for (var i = 0; i <= tubularSegments; ++i) {
        // the radian "u" is used to calculate the position on the torus curve of the current tubular segement
        var 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 (var 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.
          var v = (j / radialSegments) * Math.PI * 2
          var cx = -tube * Math.cos(v)
          var cy = tube * Math.sin(v) // now calculate the final vertex position.
          // first we orient the extrusion with our basis vectos, 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 (var _j = 1; _j <= tubularSegments; _j++) {
        for (var _i = 1; _i <= radialSegments; _i++) {
          // indices
          var a = (radialSegments + 1) * (_j - 1) + (_i - 1)
          var b = (radialSegments + 1) * _j + (_i - 1)
          var c = (radialSegments + 1) * _j + _i
          var 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 Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2)) // this function calculates the current position on the torus curve

      function calculatePositionOnCurve(u, p, q, radius, position) {
        var cu = Math.cos(u)
        var su = Math.sin(u)
        var quOverP = (q / p) * u
        var 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
      }

      return _this
    }

    return TorusKnotBufferGeometry
  })(BufferGeometry)

  var TorusKnotGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(TorusKnotGeometry, _Geometry)

    function TorusKnotGeometry(radius, tube, tubularSegments, radialSegments, p, q, heightScale) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'TorusKnotGeometry'
      _this.parameters = {
        radius: radius,
        tube: tube,
        tubularSegments: tubularSegments,
        radialSegments: radialSegments,
        p: p,
        q: q
      }
      if (heightScale !== undefined) console.warn('THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.')

      _this.fromBufferGeometry(new TorusKnotBufferGeometry(radius, tube, tubularSegments, radialSegments, p, q))

      _this.mergeVertices()

      return _this
    }

    return TorusKnotGeometry
  })(Geometry)

  var TubeBufferGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(TubeBufferGeometry, _BufferGeometry)

    function TubeBufferGeometry(path, tubularSegments, radius, radialSegments, closed) {
      var _this

      if (tubularSegments === void 0) {
        tubularSegments = 64
      }

      if (radius === void 0) {
        radius = 1
      }

      if (radialSegments === void 0) {
        radialSegments = 8
      }

      if (closed === void 0) {
        closed = false
      }

      _this = _BufferGeometry.call(this) || this
      _this.type = 'TubeBufferGeometry'
      _this.parameters = {
        path: path,
        tubularSegments: tubularSegments,
        radius: radius,
        radialSegments: radialSegments,
        closed: closed
      }
      var frames = path.computeFrenetFrames(tubularSegments, closed) // expose internals

      _this.tangents = frames.tangents
      _this.normals = frames.normals
      _this.binormals = frames.binormals // helper variables

      var vertex = new Vector3()
      var normal = new Vector3()
      var uv = new Vector2()
      var P = new Vector3() // buffer

      var vertices = []
      var normals = []
      var uvs = []
      var indices = [] // create buffer data

      generateBufferData() // build geometry

      _this.setIndex(indices)

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      _this.setAttribute('normal', new Float32BufferAttribute(normals, 3))

      _this.setAttribute('uv', new Float32BufferAttribute(uvs, 2)) // functions

      function generateBufferData() {
        for (var 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

        var N = frames.normals[i]
        var B = frames.binormals[i] // generate normals and vertices for the current segment

        for (var j = 0; j <= radialSegments; j++) {
          var v = (j / radialSegments) * Math.PI * 2
          var sin = Math.sin(v)
          var 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 (var j = 1; j <= tubularSegments; j++) {
          for (var i = 1; i <= radialSegments; i++) {
            var a = (radialSegments + 1) * (j - 1) + (i - 1)
            var b = (radialSegments + 1) * j + (i - 1)
            var c = (radialSegments + 1) * j + i
            var d = (radialSegments + 1) * (j - 1) + i // faces

            indices.push(a, b, d)
            indices.push(b, c, d)
          }
        }
      }

      function generateUVs() {
        for (var i = 0; i <= tubularSegments; i++) {
          for (var j = 0; j <= radialSegments; j++) {
            uv.x = i / tubularSegments
            uv.y = j / radialSegments
            uvs.push(uv.x, uv.y)
          }
        }
      }

      return _this
    }

    var _proto = TubeBufferGeometry.prototype

    _proto.toJSON = function toJSON() {
      var data = BufferGeometry.prototype.toJSON.call(this)
      data.path = this.parameters.path.toJSON()
      return data
    }

    return TubeBufferGeometry
  })(BufferGeometry)

  var TubeGeometry = /*#__PURE__*/ (function (_Geometry) {
    _inheritsLoose(TubeGeometry, _Geometry)

    function TubeGeometry(path, tubularSegments, radius, radialSegments, closed, taper) {
      var _this

      _this = _Geometry.call(this) || this
      _this.type = 'TubeGeometry'
      _this.parameters = {
        path: path,
        tubularSegments: tubularSegments,
        radius: radius,
        radialSegments: radialSegments,
        closed: closed
      }
      if (taper !== undefined) console.warn('THREE.TubeGeometry: taper has been removed.')
      var bufferGeometry = new TubeBufferGeometry(path, tubularSegments, radius, radialSegments, closed) // expose internals

      _this.tangents = bufferGeometry.tangents
      _this.normals = bufferGeometry.normals
      _this.binormals = bufferGeometry.binormals // create geometry

      _this.fromBufferGeometry(bufferGeometry)

      _this.mergeVertices()

      return _this
    }

    return TubeGeometry
  })(Geometry)

  var WireframeGeometry = /*#__PURE__*/ (function (_BufferGeometry) {
    _inheritsLoose(WireframeGeometry, _BufferGeometry)

    function WireframeGeometry(geometry) {
      var _this

      _this = _BufferGeometry.call(this) || this
      _this.type = 'WireframeGeometry' // buffer

      var vertices = [] // helper variables

      var edge = [0, 0],
        edges = {}
      var keys = ['a', 'b', 'c'] // different logic for Geometry and BufferGeometry

      if (geometry && geometry.isGeometry) {
        // create a data structure that contains all edges without duplicates
        var faces = geometry.faces

        for (var i = 0, l = faces.length; i < l; i++) {
          var face = faces[i]

          for (var j = 0; j < 3; j++) {
            var edge1 = face[keys[j]]
            var edge2 = face[keys[(j + 1) % 3]]
            edge[0] = Math.min(edge1, edge2) // sorting prevents duplicates

            edge[1] = Math.max(edge1, edge2)
            var key = edge[0] + ',' + edge[1]

            if (edges[key] === undefined) {
              edges[key] = {
                index1: edge[0],
                index2: edge[1]
              }
            }
          }
        } // generate vertices

        for (var _key in edges) {
          var e = edges[_key]
          var vertex = geometry.vertices[e.index1]
          vertices.push(vertex.x, vertex.y, vertex.z)
          vertex = geometry.vertices[e.index2]
          vertices.push(vertex.x, vertex.y, vertex.z)
        }
      } else if (geometry && geometry.isBufferGeometry) {
        var _vertex = new Vector3()

        if (geometry.index !== null) {
          // indexed BufferGeometry
          var position = geometry.attributes.position
          var indices = geometry.index
          var groups = geometry.groups

          if (groups.length === 0) {
            groups = [
              {
                start: 0,
                count: indices.count,
                materialIndex: 0
              }
            ]
          } // create a data structure that contains all eges without duplicates

          for (var o = 0, ol = groups.length; o < ol; ++o) {
            var group = groups[o]
            var start = group.start
            var count = group.count

            for (var _i = start, _l = start + count; _i < _l; _i += 3) {
              for (var _j = 0; _j < 3; _j++) {
                var _edge = indices.getX(_i + _j)

                var _edge2 = indices.getX(_i + ((_j + 1) % 3))

                edge[0] = Math.min(_edge, _edge2) // sorting prevents duplicates

                edge[1] = Math.max(_edge, _edge2)

                var _key2 = edge[0] + ',' + edge[1]

                if (edges[_key2] === undefined) {
                  edges[_key2] = {
                    index1: edge[0],
                    index2: edge[1]
                  }
                }
              }
            }
          } // generate vertices

          for (var _key3 in edges) {
            var _e = edges[_key3]

            _vertex.fromBufferAttribute(position, _e.index1)

            vertices.push(_vertex.x, _vertex.y, _vertex.z)

            _vertex.fromBufferAttribute(position, _e.index2)

            vertices.push(_vertex.x, _vertex.y, _vertex.z)
          }
        } else {
          // non-indexed BufferGeometry
          var _position = geometry.attributes.position

          for (var _i2 = 0, _l2 = _position.count / 3; _i2 < _l2; _i2++) {
            for (var _j2 = 0; _j2 < 3; _j2++) {
              // 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)
              var index1 = 3 * _i2 + _j2

              _vertex.fromBufferAttribute(_position, index1)

              vertices.push(_vertex.x, _vertex.y, _vertex.z)
              var index2 = 3 * _i2 + ((_j2 + 1) % 3)

              _vertex.fromBufferAttribute(_position, index2)

              vertices.push(_vertex.x, _vertex.y, _vertex.z)
            }
          }
        }
      } // build geometry

      _this.setAttribute('position', new Float32BufferAttribute(vertices, 3))

      return _this
    }

    return WireframeGeometry
  })(BufferGeometry)

  var Geometries = /*#__PURE__*/ Object.freeze({
    __proto__: null,
    BoxGeometry: BoxGeometry,
    BoxBufferGeometry: BoxBufferGeometry,
    CircleGeometry: CircleGeometry,
    CircleBufferGeometry: CircleBufferGeometry,
    ConeGeometry: ConeGeometry,
    ConeBufferGeometry: ConeBufferGeometry,
    CylinderGeometry: CylinderGeometry,
    CylinderBufferGeometry: CylinderBufferGeometry,
    DodecahedronGeometry: DodecahedronGeometry,
    DodecahedronBufferGeometry: DodecahedronBufferGeometry,
    EdgesGeometry: EdgesGeometry,
    ExtrudeGeometry: ExtrudeGeometry,
    ExtrudeBufferGeometry: ExtrudeBufferGeometry,
    IcosahedronGeometry: IcosahedronGeometry,
    IcosahedronBufferGeometry: IcosahedronBufferGeometry,
    LatheGeometry: LatheGeometry,
    LatheBufferGeometry: LatheBufferGeometry,
    OctahedronGeometry: OctahedronGeometry,
    OctahedronBufferGeometry: OctahedronBufferGeometry,
    ParametricGeometry: ParametricGeometry,
    ParametricBufferGeometry: ParametricBufferGeometry,
    PlaneGeometry: PlaneGeometry,
    PlaneBufferGeometry: PlaneBufferGeometry,
    PolyhedronGeometry: PolyhedronGeometry,
    PolyhedronBufferGeometry: PolyhedronBufferGeometry,
    RingGeometry: RingGeometry,
    RingBufferGeometry: RingBufferGeometry,
    ShapeGeometry: ShapeGeometry,
    ShapeBufferGeometry: ShapeBufferGeometry,
    SphereGeometry: SphereGeometry,
    SphereBufferGeometry: SphereBufferGeometry,
    TetrahedronGeometry: TetrahedronGeometry,
    TetrahedronBufferGeometry: TetrahedronBufferGeometry,
    TextGeometry: TextGeometry,
    TextBufferGeometry: TextBufferGeometry,
    TorusGeometry: TorusGeometry,
    TorusBufferGeometry: TorusBufferGeometry,
    TorusKnotGeometry: TorusKnotGeometry,
    TorusKnotBufferGeometry: TorusKnotBufferGeometry,
    TubeGeometry: TubeGeometry,
    TubeBufferGeometry: TubeBufferGeometry,
    WireframeGeometry: WireframeGeometry
  })

  /**
   * parameters = {
   *	color: <THREE.Color>
   * }
   */

  function ShadowMaterial(parameters) {
    Material.call(this)
    this.type = 'ShadowMaterial'
    this.color = new Color(0x000000)
    this.transparent = true
    this.setValues(parameters)
  }

  ShadowMaterial.prototype = Object.create(Material.prototype)
  ShadowMaterial.prototype.constructor = ShadowMaterial
  ShadowMaterial.prototype.isShadowMaterial = true

  ShadowMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, source)
    this.color.copy(source.color)
    return this
  }

  function RawShaderMaterial(parameters) {
    ShaderMaterial.call(this, parameters)
    this.type = 'RawShaderMaterial'
  }

  RawShaderMaterial.prototype = Object.create(ShaderMaterial.prototype)
  RawShaderMaterial.prototype.constructor = RawShaderMaterial
  RawShaderMaterial.prototype.isRawShaderMaterial = true

  /**
   * parameters = {
   *	color: <hex>,
   *	roughness: <float>,
   *	metalness: <float>,
   *	opacity: <float>,
   *
   *	map: new THREE.Texture( <Image> ),
   *
   *	lightMap: new THREE.Texture( <Image> ),
   *	lightMapIntensity: <float>
   *
   *	aoMap: new THREE.Texture( <Image> ),
   *	aoMapIntensity: <float>
   *
   *	emissive: <hex>,
   *	emissiveIntensity: <float>
   *	emissiveMap: new THREE.Texture( <Image> ),
   *
   *	bumpMap: new THREE.Texture( <Image> ),
   *	bumpScale: <float>,
   *
   *	normalMap: new THREE.Texture( <Image> ),
   *	normalMapType: THREE.TangentSpaceNormalMap,
   *	normalScale: <Vector2>,
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>,
   *
   *	roughnessMap: new THREE.Texture( <Image> ),
   *
   *	metalnessMap: new THREE.Texture( <Image> ),
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
   *	envMapIntensity: <float>
   *
   *	refractionRatio: <float>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function MeshStandardMaterial(parameters) {
    Material.call(this)
    this.defines = {
      STANDARD: ''
    }
    this.type = 'MeshStandardMaterial'
    this.color = new Color(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 Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null
    this.bumpMap = null
    this.bumpScale = 1
    this.normalMap = null
    this.normalMapType = TangentSpaceNormalMap
    this.normalScale = new Vector2(1, 1)
    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0
    this.roughnessMap = null
    this.metalnessMap = null
    this.alphaMap = null
    this.envMap = null
    this.envMapIntensity = 1.0
    this.refractionRatio = 0.98
    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'
    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false
    this.vertexTangents = false
    this.setValues(parameters)
  }

  MeshStandardMaterial.prototype = Object.create(Material.prototype)
  MeshStandardMaterial.prototype.constructor = MeshStandardMaterial
  MeshStandardMaterial.prototype.isMeshStandardMaterial = true

  MeshStandardMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.envMapIntensity = source.envMapIntensity
    this.refractionRatio = source.refractionRatio
    this.wireframe = source.wireframe
    this.wireframeLinewidth = source.wireframeLinewidth
    this.wireframeLinecap = source.wireframeLinecap
    this.wireframeLinejoin = source.wireframeLinejoin
    this.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    this.vertexTangents = source.vertexTangents
    return this
  }

  /**
   * parameters = {
   *	clearcoat: <float>,
   *	clearcoatMap: new THREE.Texture( <Image> ),
   *	clearcoatRoughness: <float>,
   *	clearcoatRoughnessMap: new THREE.Texture( <Image> ),
   *	clearcoatNormalScale: <Vector2>,
   *	clearcoatNormalMap: new THREE.Texture( <Image> ),
   *
   *	reflectivity: <float>,
   *	ior: <float>,
   *
   *	sheen: <Color>,
   *
   *	transmission: <float>,
   *	transmissionMap: new THREE.Texture( <Image> )
   * }
   */

  function MeshPhysicalMaterial(parameters) {
    MeshStandardMaterial.call(this)
    this.defines = {
      STANDARD: '',
      PHYSICAL: ''
    }
    this.type = 'MeshPhysicalMaterial'
    this.clearcoat = 0.0
    this.clearcoatMap = null
    this.clearcoatRoughness = 0.0
    this.clearcoatRoughnessMap = null
    this.clearcoatNormalScale = new Vector2(1, 1)
    this.clearcoatNormalMap = null
    this.reflectivity = 0.5 // maps to F0 = 0.04

    Object.defineProperty(this, 'ior', {
      get: function get() {
        return (1 + 0.4 * this.reflectivity) / (1 - 0.4 * this.reflectivity)
      },
      set: function set(ior) {
        this.reflectivity = MathUtils.clamp((2.5 * (ior - 1)) / (ior + 1), 0, 1)
      }
    })
    this.sheen = null // null will disable sheen bsdf

    this.transmission = 0.0
    this.transmissionMap = null
    this.setValues(parameters)
  }

  MeshPhysicalMaterial.prototype = Object.create(MeshStandardMaterial.prototype)
  MeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial
  MeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true

  MeshPhysicalMaterial.prototype.copy = function (source) {
    MeshStandardMaterial.prototype.copy.call(this, source)
    this.defines = {
      STANDARD: '',
      PHYSICAL: ''
    }
    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.reflectivity = source.reflectivity

    if (source.sheen) {
      this.sheen = (this.sheen || new Color()).copy(source.sheen)
    } else {
      this.sheen = null
    }

    this.transmission = source.transmission
    this.transmissionMap = source.transmissionMap
    return this
  }

  /**
   * parameters = {
   *	color: <hex>,
   *	specular: <hex>,
   *	shininess: <float>,
   *	opacity: <float>,
   *
   *	map: new THREE.Texture( <Image> ),
   *
   *	lightMap: new THREE.Texture( <Image> ),
   *	lightMapIntensity: <float>
   *
   *	aoMap: new THREE.Texture( <Image> ),
   *	aoMapIntensity: <float>
   *
   *	emissive: <hex>,
   *	emissiveIntensity: <float>
   *	emissiveMap: new THREE.Texture( <Image> ),
   *
   *	bumpMap: new THREE.Texture( <Image> ),
   *	bumpScale: <float>,
   *
   *	normalMap: new THREE.Texture( <Image> ),
   *	normalMapType: THREE.TangentSpaceNormalMap,
   *	normalScale: <Vector2>,
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>,
   *
   *	specularMap: new THREE.Texture( <Image> ),
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
   *	combine: THREE.MultiplyOperation,
   *	reflectivity: <float>,
   *	refractionRatio: <float>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function MeshPhongMaterial(parameters) {
    Material.call(this)
    this.type = 'MeshPhongMaterial'
    this.color = new Color(0xffffff) // diffuse

    this.specular = new Color(0x111111)
    this.shininess = 30
    this.map = null
    this.lightMap = null
    this.lightMapIntensity = 1.0
    this.aoMap = null
    this.aoMapIntensity = 1.0
    this.emissive = new Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null
    this.bumpMap = null
    this.bumpScale = 1
    this.normalMap = null
    this.normalMapType = TangentSpaceNormalMap
    this.normalScale = new Vector2(1, 1)
    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0
    this.specularMap = null
    this.alphaMap = null
    this.envMap = null
    this.combine = MultiplyOperation
    this.reflectivity = 1
    this.refractionRatio = 0.98
    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'
    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false
    this.setValues(parameters)
  }

  MeshPhongMaterial.prototype = Object.create(Material.prototype)
  MeshPhongMaterial.prototype.constructor = MeshPhongMaterial
  MeshPhongMaterial.prototype.isMeshPhongMaterial = true

  MeshPhongMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.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.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    return this
  }

  /**
   * parameters = {
   *	color: <hex>,
   *
   *	map: new THREE.Texture( <Image> ),
   *	gradientMap: new THREE.Texture( <Image> ),
   *
   *	lightMap: new THREE.Texture( <Image> ),
   *	lightMapIntensity: <float>
   *
   *	aoMap: new THREE.Texture( <Image> ),
   *	aoMapIntensity: <float>
   *
   *	emissive: <hex>,
   *	emissiveIntensity: <float>
   *	emissiveMap: new THREE.Texture( <Image> ),
   *
   *	bumpMap: new THREE.Texture( <Image> ),
   *	bumpScale: <float>,
   *
   *	normalMap: new THREE.Texture( <Image> ),
   *	normalMapType: THREE.TangentSpaceNormalMap,
   *	normalScale: <Vector2>,
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>,
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function MeshToonMaterial(parameters) {
    Material.call(this)
    this.defines = {
      TOON: ''
    }
    this.type = 'MeshToonMaterial'
    this.color = new Color(0xffffff)
    this.map = null
    this.gradientMap = null
    this.lightMap = null
    this.lightMapIntensity = 1.0
    this.aoMap = null
    this.aoMapIntensity = 1.0
    this.emissive = new Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null
    this.bumpMap = null
    this.bumpScale = 1
    this.normalMap = null
    this.normalMapType = TangentSpaceNormalMap
    this.normalScale = new Vector2(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.skinning = false
    this.morphTargets = false
    this.morphNormals = false
    this.setValues(parameters)
  }

  MeshToonMaterial.prototype = Object.create(Material.prototype)
  MeshToonMaterial.prototype.constructor = MeshToonMaterial
  MeshToonMaterial.prototype.isMeshToonMaterial = true

  MeshToonMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    return this
  }

  /**
   * parameters = {
   *	opacity: <float>,
   *
   *	bumpMap: new THREE.Texture( <Image> ),
   *	bumpScale: <float>,
   *
   *	normalMap: new THREE.Texture( <Image> ),
   *	normalMapType: THREE.TangentSpaceNormalMap,
   *	normalScale: <Vector2>,
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function MeshNormalMaterial(parameters) {
    Material.call(this)
    this.type = 'MeshNormalMaterial'
    this.bumpMap = null
    this.bumpScale = 1
    this.normalMap = null
    this.normalMapType = TangentSpaceNormalMap
    this.normalScale = new Vector2(1, 1)
    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0
    this.wireframe = false
    this.wireframeLinewidth = 1
    this.fog = false
    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false
    this.setValues(parameters)
  }

  MeshNormalMaterial.prototype = Object.create(Material.prototype)
  MeshNormalMaterial.prototype.constructor = MeshNormalMaterial
  MeshNormalMaterial.prototype.isMeshNormalMaterial = true

  MeshNormalMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    return this
  }

  /**
   * parameters = {
   *	color: <hex>,
   *	opacity: <float>,
   *
   *	map: new THREE.Texture( <Image> ),
   *
   *	lightMap: new THREE.Texture( <Image> ),
   *	lightMapIntensity: <float>
   *
   *	aoMap: new THREE.Texture( <Image> ),
   *	aoMapIntensity: <float>
   *
   *	emissive: <hex>,
   *	emissiveIntensity: <float>
   *	emissiveMap: new THREE.Texture( <Image> ),
   *
   *	specularMap: new THREE.Texture( <Image> ),
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
   *	combine: THREE.Multiply,
   *	reflectivity: <float>,
   *	refractionRatio: <float>,
   *
   *	wireframe: <boolean>,
   *	wireframeLinewidth: <float>,
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function MeshLambertMaterial(parameters) {
    Material.call(this)
    this.type = 'MeshLambertMaterial'
    this.color = new Color(0xffffff) // diffuse

    this.map = null
    this.lightMap = null
    this.lightMapIntensity = 1.0
    this.aoMap = null
    this.aoMapIntensity = 1.0
    this.emissive = new Color(0x000000)
    this.emissiveIntensity = 1.0
    this.emissiveMap = null
    this.specularMap = null
    this.alphaMap = null
    this.envMap = null
    this.combine = MultiplyOperation
    this.reflectivity = 1
    this.refractionRatio = 0.98
    this.wireframe = false
    this.wireframeLinewidth = 1
    this.wireframeLinecap = 'round'
    this.wireframeLinejoin = 'round'
    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false
    this.setValues(parameters)
  }

  MeshLambertMaterial.prototype = Object.create(Material.prototype)
  MeshLambertMaterial.prototype.constructor = MeshLambertMaterial
  MeshLambertMaterial.prototype.isMeshLambertMaterial = true

  MeshLambertMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.specularMap = source.specularMap
    this.alphaMap = source.alphaMap
    this.envMap = source.envMap
    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.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    return this
  }

  /**
   * parameters = {
   *	color: <hex>,
   *	opacity: <float>,
   *
   *	matcap: new THREE.Texture( <Image> ),
   *
   *	map: new THREE.Texture( <Image> ),
   *
   *	bumpMap: new THREE.Texture( <Image> ),
   *	bumpScale: <float>,
   *
   *	normalMap: new THREE.Texture( <Image> ),
   *	normalMapType: THREE.TangentSpaceNormalMap,
   *	normalScale: <Vector2>,
   *
   *	displacementMap: new THREE.Texture( <Image> ),
   *	displacementScale: <float>,
   *	displacementBias: <float>,
   *
   *	alphaMap: new THREE.Texture( <Image> ),
   *
   *	skinning: <bool>,
   *	morphTargets: <bool>,
   *	morphNormals: <bool>
   * }
   */

  function MeshMatcapMaterial(parameters) {
    Material.call(this)
    this.defines = {
      MATCAP: ''
    }
    this.type = 'MeshMatcapMaterial'
    this.color = new Color(0xffffff) // diffuse

    this.matcap = null
    this.map = null
    this.bumpMap = null
    this.bumpScale = 1
    this.normalMap = null
    this.normalMapType = TangentSpaceNormalMap
    this.normalScale = new Vector2(1, 1)
    this.displacementMap = null
    this.displacementScale = 1
    this.displacementBias = 0
    this.alphaMap = null
    this.skinning = false
    this.morphTargets = false
    this.morphNormals = false
    this.setValues(parameters)
  }

  MeshMatcapMaterial.prototype = Object.create(Material.prototype)
  MeshMatcapMaterial.prototype.constructor = MeshMatcapMaterial
  MeshMatcapMaterial.prototype.isMeshMatcapMaterial = true

  MeshMatcapMaterial.prototype.copy = function (source) {
    Material.prototype.copy.call(this, 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.skinning = source.skinning
    this.morphTargets = source.morphTargets
    this.morphNormals = source.morphNormals
    return this
  }

  /**
   * parameters = {
   *	color: <hex>,
   *	opacity: <float>,
   *
   *	linewidth: <float>,
   *
   *	scale: <float>,
   *	dashSize: <float>,
   *	gapSize: <float>
   * }
   */

  function LineDashedMaterial(parameters) {
    LineBasicMaterial.call(this)
    this.type = 'LineDashedMaterial'
    this.scale = 1
    this.dashSize = 3
    this.gapSize = 1
    this.setValues(parameters)
  }

  LineDashedMaterial.prototype = Object.create(LineBasicMaterial.prototype)
  LineDashedMaterial.prototype.constructor = LineDashedMaterial
  LineDashedMaterial.prototype.isLineDashedMaterial = true

  LineDashedMaterial.prototype.copy = function (source) {
    LineBasicMaterial.prototype.copy.call(this, source)
    this.scale = source.scale
    this.dashSize = source.dashSize
    this.gapSize = source.gapSize
    return this
  }

  var Materials = /*#__PURE__*/ Object.freeze({
    __proto__: null,
    ShadowMaterial: ShadowMaterial,
    SpriteMaterial: SpriteMaterial,
    RawShaderMaterial: RawShaderMaterial,
    ShaderMaterial: ShaderMaterial,
    PointsMaterial: PointsMaterial,
    MeshPhysicalMaterial: MeshPhysicalMaterial,
    MeshStandardMaterial: MeshStandardMaterial,
    MeshPhongMaterial: MeshPhongMaterial,
    MeshToonMaterial: MeshToonMaterial,
    MeshNormalMaterial: MeshNormalMaterial,
    MeshLambertMaterial: MeshLambertMaterial,
    MeshDepthMaterial: MeshDepthMaterial,
    MeshDistanceMaterial: MeshDistanceMaterial,
    MeshBasicMaterial: MeshBasicMaterial,
    MeshMatcapMaterial: MeshMatcapMaterial,
    LineDashedMaterial: LineDashedMaterial,
    LineBasicMaterial: LineBasicMaterial,
    Material: Material
  })

  var AnimationUtils = {
    // same as Array.prototype.slice, but also works on typed arrays
    arraySlice: function arraySlice(array, from, to) {
      if (AnimationUtils.isTypedArray(array)) {
        // in ios9 array.subarray(from, undefined) will return empty array
        // but array.subarray(from) or array.subarray(from, len) is correct
        return new array.constructor(array.subarray(from, to !== undefined ? to : array.length))
      }

      return array.slice(from, to)
    },
    // converts an array to a specific type
    convertArray: function 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
    },
    isTypedArray: function isTypedArray(object) {
      return ArrayBuffer.isView(object) && !(object instanceof DataView)
    },
    // returns an array by which times and values can be sorted
    getKeyframeOrder: function getKeyframeOrder(times) {
      function compareTime(i, j) {
        return times[i] - times[j]
      }

      var n = times.length
      var result = new Array(n)

      for (var i = 0; i !== n; ++i) {
        result[i] = i
      }

      result.sort(compareTime)
      return result
    },
    // uses the array previously returned by 'getKeyframeOrder' to sort data
    sortedArray: function sortedArray(values, stride, order) {
      var nValues = values.length
      var result = new values.constructor(nValues)

      for (var i = 0, dstOffset = 0; dstOffset !== nValues; ++i) {
        var srcOffset = order[i] * stride

        for (var j = 0; j !== stride; ++j) {
          result[dstOffset++] = values[srcOffset + j]
        }
      }

      return result
    },
    // function for parsing AOS keyframe formats
    flattenJSON: function flattenJSON(jsonKeys, times, values, valuePropertyName) {
      var i = 1,
        key = jsonKeys[0]

      while (key !== undefined && key[valuePropertyName] === undefined) {
        key = jsonKeys[i++]
      }

      if (key === undefined) return // no data

      var 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)
      }
    },
    subclip: function subclip(sourceClip, name, startFrame, endFrame, fps) {
      if (fps === void 0) {
        fps = 30
      }

      var clip = sourceClip.clone()
      clip.name = name
      var tracks = []

      for (var i = 0; i < clip.tracks.length; ++i) {
        var track = clip.tracks[i]
        var valueSize = track.getValueSize()
        var times = []
        var values = []

        for (var j = 0; j < track.times.length; ++j) {
          var frame = track.times[j] * fps
          if (frame < startFrame || frame >= endFrame) continue
          times.push(track.times[j])

          for (var k = 0; k < valueSize; ++k) {
            values.push(track.values[j * valueSize + k])
          }
        }

        if (times.length === 0) continue
        track.times = AnimationUtils.convertArray(times, track.times.constructor)
        track.values = AnimationUtils.convertArray(values, track.values.constructor)
        tracks.push(track)
      }

      clip.tracks = tracks // find minimum .times value across all tracks in the trimmed clip

      var minStartTime = Infinity

      for (var _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 (var _i2 = 0; _i2 < clip.tracks.length; ++_i2) {
        clip.tracks[_i2].shift(-1 * minStartTime)
      }

      clip.resetDuration()
      return clip
    },
    makeClipAdditive: function makeClipAdditive(targetClip, referenceFrame, referenceClip, fps) {
      if (referenceFrame === void 0) {
        referenceFrame = 0
      }

      if (referenceClip === void 0) {
        referenceClip = targetClip
      }

      if (fps === void 0) {
        fps = 30
      }

      if (fps <= 0) fps = 30
      var numTracks = referenceClip.tracks.length
      var referenceTime = referenceFrame / fps // Make each track's values relative to the values at the reference frame

      var _loop = function _loop(i) {
        var referenceTrack = referenceClip.tracks[i]
        var referenceTrackType = referenceTrack.ValueTypeName // Skip this track if it's non-numeric

        if (referenceTrackType === 'bool' || referenceTrackType === 'string') return 'continue' // Find the track in the target clip whose name and type matches the reference track

        var targetTrack = targetClip.tracks.find(function (track) {
          return track.name === referenceTrack.name && track.ValueTypeName === referenceTrackType
        })
        if (targetTrack === undefined) return 'continue'
        var referenceOffset = 0
        var referenceValueSize = referenceTrack.getValueSize()

        if (referenceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
          referenceOffset = referenceValueSize / 3
        }

        var targetOffset = 0
        var targetValueSize = targetTrack.getValueSize()

        if (targetTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
          targetOffset = targetValueSize / 3
        }

        var lastIndex = referenceTrack.times.length - 1
        var referenceValue = void 0 // 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
          var startIndex = referenceOffset
          var endIndex = referenceValueSize - referenceOffset
          referenceValue = AnimationUtils.arraySlice(referenceTrack.values, startIndex, endIndex)
        } else if (referenceTime >= referenceTrack.times[lastIndex]) {
          // Reference frame is after the last keyframe, so just use the last keyframe
          var _startIndex = lastIndex * referenceValueSize + referenceOffset

          var _endIndex = _startIndex + referenceValueSize - referenceOffset

          referenceValue = AnimationUtils.arraySlice(referenceTrack.values, _startIndex, _endIndex)
        } else {
          // Interpolate to the reference value
          var interpolant = referenceTrack.createInterpolant()
          var _startIndex2 = referenceOffset

          var _endIndex2 = referenceValueSize - referenceOffset

          interpolant.evaluate(referenceTime)
          referenceValue = AnimationUtils.arraySlice(interpolant.resultBuffer, _startIndex2, _endIndex2)
        } // Conjugate the quaternion

        if (referenceTrackType === 'quaternion') {
          var referenceQuat = new Quaternion().fromArray(referenceValue).normalize().conjugate()
          referenceQuat.toArray(referenceValue)
        } // Subtract the reference value from all of the track values

        var numTimes = targetTrack.times.length

        for (var j = 0; j < numTimes; ++j) {
          var valueStart = j * targetValueSize + targetOffset

          if (referenceTrackType === 'quaternion') {
            // Multiply the conjugate for quaternion track types
            Quaternion.multiplyQuaternionsFlat(targetTrack.values, valueStart, referenceValue, 0, targetTrack.values, valueStart)
          } else {
            var valueEnd = targetValueSize - targetOffset * 2 // Subtract each value for all other numeric track types

            for (var k = 0; k < valueEnd; ++k) {
              targetTrack.values[valueStart + k] -= referenceValue[k]
            }
          }
        }
      }

      for (var i = 0; i < numTracks; ++i) {
        var _ret = _loop(i)

        if (_ret === 'continue') continue
      }

      targetClip.blendMode = AdditiveAnimationBlendMode
      return targetClip
    }
  }

  /**
   * 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
   *
   */
  function Interpolant(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
  }

  Object.assign(Interpolant.prototype, {
    evaluate: function evaluate(t) {
      var pp = this.parameterPositions
      var i1 = this._cachedIndex,
        t1 = pp[i1],
        t0 = pp[i1 - 1]

      validate_interval: {
        seek: {
          var right

          linear_scan: {
            //- See http://jsperf.com/comparison-to-undefined/3
            //- slower code:
            //-
            //- 				if ( t >= t1 || t1 === undefined ) {
            forward_scan: if (!(t < t1)) {
              for (var giveUpAt = i1 + 2; ; ) {
                if (t1 === undefined) {
                  if (t < t0) break forward_scan // after end

                  i1 = pp.length
                  this._cachedIndex = i1
                  return this.afterEnd_(i1 - 1, t, t0)
                }

                if (i1 === giveUpAt) break // this loop

                t0 = t1
                t1 = pp[++i1]

                if (t < t1) {
                  // we have arrived at the sought interval
                  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?
              var t1global = pp[1]

              if (t < t1global) {
                i1 = 2 // + 1, using the scan for the details

                t0 = t1global
              } // linear reverse scan

              for (var _giveUpAt = i1 - 2; ; ) {
                if (t0 === undefined) {
                  // before start
                  this._cachedIndex = 0
                  return this.beforeStart_(0, t, t1)
                }

                if (i1 === _giveUpAt) break // this loop

                t1 = t0
                t0 = pp[--i1 - 1]

                if (t >= t0) {
                  // we have arrived at the sought interval
                  break seek
                }
              } // prepare binary search on the left side of the index

              right = i1
              i1 = 0
              break linear_scan
            } // the interval is valid

            break validate_interval
          } // linear scan
          // binary search

          while (i1 < right) {
            var 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.beforeStart_(0, t, t1)
          }

          if (t1 === undefined) {
            i1 = pp.length
            this._cachedIndex = i1
            return this.afterEnd_(i1 - 1, t0, t)
          }
        } // seek

        this._cachedIndex = i1
        this.intervalChanged_(i1, t0, t1)
      } // validate_interval

      return this.interpolate_(i1, t0, t, t1)
    },
    settings: null,
    // optional, subclass-specific settings structure
    // Note: The indirection allows central control of many interpolants.
    // --- Protected interface
    DefaultSettings_: {},
    getSettings_: function getSettings_() {
      return this.settings || this.DefaultSettings_
    },
    copySampleValue_: function copySampleValue_(index) {
      // copies a sample value to the result buffer
      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        offset = index * stride

      for (var i = 0; i !== stride; ++i) {
        result[i] = values[offset + i]
      }

      return result
    },
    // Template methods for derived classes:
    interpolate_: function interpolate_() /* i1, t0, t, t1 */
    {
      throw new Error('call to abstract method') // implementations shall return this.resultBuffer
    },
    intervalChanged_: function intervalChanged_() /* i1, t0, t1 */
    {
      // empty
    }
  }) // DECLARE ALIAS AFTER assign prototype

  Object.assign(Interpolant.prototype, {
    //( 0, t, t0 ), returns this.resultBuffer
    beforeStart_: Interpolant.prototype.copySampleValue_,
    //( N-1, tN-1, t ), returns this.resultBuffer
    afterEnd_: Interpolant.prototype.copySampleValue_
  })

  /**
   * 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.
   */

  function CubicInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
    this._weightPrev = -0
    this._offsetPrev = -0
    this._weightNext = -0
    this._offsetNext = -0
  }

  CubicInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: CubicInterpolant,
    DefaultSettings_: {
      endingStart: ZeroCurvatureEnding,
      endingEnd: ZeroCurvatureEnding
    },
    intervalChanged_: function intervalChanged_(i1, t0, t1) {
      var pp = this.parameterPositions
      var iPrev = i1 - 2,
        iNext = i1 + 1,
        tPrev = pp[iPrev],
        tNext = pp[iNext]

      if (tPrev === undefined) {
        switch (this.getSettings_().endingStart) {
          case ZeroSlopeEnding:
            // f'(t0) = 0
            iPrev = i1
            tPrev = 2 * t0 - t1
            break

          case WrapAroundEnding:
            // use the other end of the curve
            iPrev = pp.length - 2
            tPrev = t0 + pp[iPrev] - pp[iPrev + 1]
            break

          default:
            // ZeroCurvatureEnding
            // f''(t0) = 0 a.k.a. Natural Spline
            iPrev = i1
            tPrev = t1
        }
      }

      if (tNext === undefined) {
        switch (this.getSettings_().endingEnd) {
          case ZeroSlopeEnding:
            // f'(tN) = 0
            iNext = i1
            tNext = 2 * t1 - t0
            break

          case WrapAroundEnding:
            // use the other end of the curve
            iNext = 1
            tNext = t1 + pp[1] - pp[0]
            break

          default:
            // ZeroCurvatureEnding
            // f''(tN) = 0, a.k.a. Natural Spline
            iNext = i1 - 1
            tNext = t0
        }
      }

      var 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_: function interpolate_(i1, t0, t, t1) {
      var 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

      var sP = -wP * ppp + 2 * wP * pp - wP * p
      var s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p + 1
      var s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p
      var sN = wN * ppp - wN * pp // combine data linearly

      for (var 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
    }
  })

  function LinearInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  LinearInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: LinearInterpolant,
    interpolate_: function interpolate_(i1, t0, t, t1) {
      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        offset1 = i1 * stride,
        offset0 = offset1 - stride,
        weight1 = (t - t0) / (t1 - t0),
        weight0 = 1 - weight1

      for (var 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 preceeding
   * the parameter.
   */

  function DiscreteInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  DiscreteInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: DiscreteInterpolant,
    interpolate_: function interpolate_(
      i1
      /*, t0, t, t1 */
    ) {
      return this.copySampleValue_(i1 - 1)
    }
  })

  function KeyframeTrack(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 = AnimationUtils.convertArray(times, this.TimeBufferType)
    this.values = AnimationUtils.convertArray(values, this.ValueBufferType)
    this.setInterpolation(interpolation || this.DefaultInterpolation)
  } // Static methods

  Object.assign(KeyframeTrack, {
    // Serialization (in static context, because of constructor invocation
    // and automatic invocation of .toJSON):
    toJSON: function toJSON(track) {
      var trackType = track.constructor
      var json // derived classes can define a static toJSON method

      if (trackType.toJSON !== undefined) {
        json = trackType.toJSON(track)
      } else {
        // by default, we assume the data can be serialized as-is
        json = {
          name: track.name,
          times: AnimationUtils.convertArray(track.times, Array),
          values: AnimationUtils.convertArray(track.values, Array)
        }
        var interpolation = track.getInterpolation()

        if (interpolation !== track.DefaultInterpolation) {
          json.interpolation = interpolation
        }
      }

      json.type = track.ValueTypeName // mandatory

      return json
    }
  })
  Object.assign(KeyframeTrack.prototype, {
    constructor: KeyframeTrack,
    TimeBufferType: Float32Array,
    ValueBufferType: Float32Array,
    DefaultInterpolation: InterpolateLinear,
    InterpolantFactoryMethodDiscrete: function InterpolantFactoryMethodDiscrete(result) {
      return new DiscreteInterpolant(this.times, this.values, this.getValueSize(), result)
    },
    InterpolantFactoryMethodLinear: function InterpolantFactoryMethodLinear(result) {
      return new LinearInterpolant(this.times, this.values, this.getValueSize(), result)
    },
    InterpolantFactoryMethodSmooth: function InterpolantFactoryMethodSmooth(result) {
      return new CubicInterpolant(this.times, this.values, this.getValueSize(), result)
    },
    setInterpolation: function setInterpolation(interpolation) {
      var factoryMethod

      switch (interpolation) {
        case InterpolateDiscrete:
          factoryMethod = this.InterpolantFactoryMethodDiscrete
          break

        case InterpolateLinear:
          factoryMethod = this.InterpolantFactoryMethodLinear
          break

        case InterpolateSmooth:
          factoryMethod = this.InterpolantFactoryMethodSmooth
          break
      }

      if (factoryMethod === undefined) {
        var 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: function getInterpolation() {
      switch (this.createInterpolant) {
        case this.InterpolantFactoryMethodDiscrete:
          return InterpolateDiscrete

        case this.InterpolantFactoryMethodLinear:
          return InterpolateLinear

        case this.InterpolantFactoryMethodSmooth:
          return InterpolateSmooth
      }
    },
    getValueSize: function getValueSize() {
      return this.values.length / this.times.length
    },
    // move all keyframes either forwards or backwards in time
    shift: function shift(timeOffset) {
      if (timeOffset !== 0.0) {
        var times = this.times

        for (var 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: function scale(timeScale) {
      if (timeScale !== 1.0) {
        var times = this.times

        for (var 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: function trim(startTime, endTime) {
      var times = this.times,
        nKeys = times.length
      var 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
        }

        var stride = this.getValueSize()
        this.times = AnimationUtils.arraySlice(times, from, to)
        this.values = AnimationUtils.arraySlice(this.values, from * stride, to * stride)
      }

      return this
    },
    // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
    validate: function validate() {
      var valid = true
      var valueSize = this.getValueSize()

      if (valueSize - Math.floor(valueSize) !== 0) {
        console.error('THREE.KeyframeTrack: Invalid value size in track.', this)
        valid = false
      }

      var times = this.times,
        values = this.values,
        nKeys = times.length

      if (nKeys === 0) {
        console.error('THREE.KeyframeTrack: Track is empty.', this)
        valid = false
      }

      var prevTime = null

      for (var i = 0; i !== nKeys; i++) {
        var 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 (AnimationUtils.isTypedArray(values)) {
          for (var _i = 0, n = values.length; _i !== n; ++_i) {
            var 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: function optimize() {
      // times or values may be shared with other tracks, so overwriting is unsafe
      var times = AnimationUtils.arraySlice(this.times),
        values = AnimationUtils.arraySlice(this.values),
        stride = this.getValueSize(),
        smoothInterpolation = this.getInterpolation() === InterpolateSmooth,
        lastIndex = times.length - 1
      var writeIndex = 1

      for (var i = 1; i < lastIndex; ++i) {
        var keep = false
        var time = times[i]
        var timeNext = times[i + 1] // remove adjacent keyframes scheduled at the same time

        if (time !== timeNext && (i !== 1 || time !== time[0])) {
          if (!smoothInterpolation) {
            // remove unnecessary keyframes same as their neighbors
            var offset = i * stride,
              offsetP = offset - stride,
              offsetN = offset + stride

            for (var j = 0; j !== stride; ++j) {
              var 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]
            var readOffset = i * stride,
              writeOffset = writeIndex * stride

            for (var _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 (var _readOffset = lastIndex * stride, _writeOffset = writeIndex * stride, _j2 = 0; _j2 !== stride; ++_j2) {
          values[_writeOffset + _j2] = values[_readOffset + _j2]
        }

        ++writeIndex
      }

      if (writeIndex !== times.length) {
        this.times = AnimationUtils.arraySlice(times, 0, writeIndex)
        this.values = AnimationUtils.arraySlice(values, 0, writeIndex * stride)
      } else {
        this.times = times
        this.values = values
      }

      return this
    },
    clone: function clone() {
      var times = AnimationUtils.arraySlice(this.times, 0)
      var values = AnimationUtils.arraySlice(this.values, 0)
      var TypedKeyframeTrack = this.constructor
      var 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
    }
  })

  /**
   * A Track of Boolean keyframe values.
   */

  function BooleanKeyframeTrack(name, times, values) {
    KeyframeTrack.call(this, name, times, values)
  }

  BooleanKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: BooleanKeyframeTrack,
    ValueTypeName: 'bool',
    ValueBufferType: Array,
    DefaultInterpolation: InterpolateDiscrete,
    InterpolantFactoryMethodLinear: undefined,
    InterpolantFactoryMethodSmooth: undefined // Note: Actually this track could have a optimized / compressed
    // representation of a single value and a custom interpolant that
    // computes "firstValue ^ isOdd( index )".
  })

  /**
   * A Track of keyframe values that represent color.
   */

  function ColorKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  ColorKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: ColorKeyframeTrack,
    ValueTypeName: 'color' // ValueBufferType is inherited
    // DefaultInterpolation is inherited
    // Note: Very basic implementation and nothing special yet.
    // However, this is the place for color space parameterization.
  })

  /**
   * A Track of numeric keyframe values.
   */

  function NumberKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  NumberKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: NumberKeyframeTrack,
    ValueTypeName: 'number' // ValueBufferType is inherited
    // DefaultInterpolation is inherited
  })

  /**
   * Spherical linear unit quaternion interpolant.
   */

  function QuaternionLinearInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  QuaternionLinearInterpolant.prototype = Object.assign(Object.create(Interpolant.prototype), {
    constructor: QuaternionLinearInterpolant,
    interpolate_: function interpolate_(i1, t0, t, t1) {
      var result = this.resultBuffer,
        values = this.sampleValues,
        stride = this.valueSize,
        alpha = (t - t0) / (t1 - t0)
      var offset = i1 * stride

      for (var end = offset + stride; offset !== end; offset += 4) {
        Quaternion.slerpFlat(result, 0, values, offset - stride, values, offset, alpha)
      }

      return result
    }
  })

  /**
   * A Track of quaternion keyframe values.
   */

  function QuaternionKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  QuaternionKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: QuaternionKeyframeTrack,
    ValueTypeName: 'quaternion',
    // ValueBufferType is inherited
    DefaultInterpolation: InterpolateLinear,
    InterpolantFactoryMethodLinear: function InterpolantFactoryMethodLinear(result) {
      return new QuaternionLinearInterpolant(this.times, this.values, this.getValueSize(), result)
    },
    InterpolantFactoryMethodSmooth: undefined // not yet implemented
  })

  /**
   * A Track that interpolates Strings
   */

  function StringKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  StringKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: StringKeyframeTrack,
    ValueTypeName: 'string',
    ValueBufferType: Array,
    DefaultInterpolation: InterpolateDiscrete,
    InterpolantFactoryMethodLinear: undefined,
    InterpolantFactoryMethodSmooth: undefined
  })

  /**
   * A Track of vectored keyframe values.
   */

  function VectorKeyframeTrack(name, times, values, interpolation) {
    KeyframeTrack.call(this, name, times, values, interpolation)
  }

  VectorKeyframeTrack.prototype = Object.assign(Object.create(KeyframeTrack.prototype), {
    constructor: VectorKeyframeTrack,
    ValueTypeName: 'vector' // ValueBufferType is inherited
    // DefaultInterpolation is inherited
  })

  function AnimationClip(name, duration, tracks, blendMode) {
    this.name = name
    this.tracks = tracks
    this.duration = duration !== undefined ? duration : -1
    this.blendMode = blendMode !== undefined ? blendMode : NormalAnimationBlendMode
    this.uuid = MathUtils.generateUUID() // this means it should figure out its duration by scanning the tracks

    if (this.duration < 0) {
      this.resetDuration()
    }
  }

  function getTrackTypeForValueTypeName(typeName) {
    switch (typeName.toLowerCase()) {
      case 'scalar':
      case 'double':
      case 'float':
      case 'number':
      case 'integer':
        return NumberKeyframeTrack

      case 'vector':
      case 'vector2':
      case 'vector3':
      case 'vector4':
        return VectorKeyframeTrack

      case 'color':
        return ColorKeyframeTrack

      case 'quaternion':
        return QuaternionKeyframeTrack

      case 'bool':
      case 'boolean':
        return BooleanKeyframeTrack

      case 'string':
        return StringKeyframeTrack
    }

    throw new Error('THREE.KeyframeTrack: Unsupported typeName: ' + typeName)
  }

  function parseKeyframeTrack(json) {
    if (json.type === undefined) {
      throw new Error('THREE.KeyframeTrack: track type undefined, can not parse')
    }

    var trackType = getTrackTypeForValueTypeName(json.type)

    if (json.times === undefined) {
      var times = [],
        values = []
      AnimationUtils.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)
    }
  }

  Object.assign(AnimationClip, {
    parse: function parse(json) {
      var tracks = [],
        jsonTracks = json.tracks,
        frameTime = 1.0 / (json.fps || 1.0)

      for (var i = 0, n = jsonTracks.length; i !== n; ++i) {
        tracks.push(parseKeyframeTrack(jsonTracks[i]).scale(frameTime))
      }

      var clip = new AnimationClip(json.name, json.duration, tracks, json.blendMode)
      clip.uuid = json.uuid
      return clip
    },
    toJSON: function toJSON(clip) {
      var tracks = [],
        clipTracks = clip.tracks
      var json = {
        name: clip.name,
        duration: clip.duration,
        tracks: tracks,
        uuid: clip.uuid,
        blendMode: clip.blendMode
      }

      for (var i = 0, n = clipTracks.length; i !== n; ++i) {
        tracks.push(KeyframeTrack.toJSON(clipTracks[i]))
      }

      return json
    },
    CreateFromMorphTargetSequence: function CreateFromMorphTargetSequence(name, morphTargetSequence, fps, noLoop) {
      var numMorphTargets = morphTargetSequence.length
      var tracks = []

      for (var i = 0; i < numMorphTargets; i++) {
        var times = []
        var values = []
        times.push((i + numMorphTargets - 1) % numMorphTargets, i, (i + 1) % numMorphTargets)
        values.push(0, 1, 0)
        var order = AnimationUtils.getKeyframeOrder(times)
        times = AnimationUtils.sortedArray(times, 1, order)
        values = AnimationUtils.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 NumberKeyframeTrack('.morphTargetInfluences[' + morphTargetSequence[i].name + ']', times, values).scale(1.0 / fps))
      }

      return new AnimationClip(name, -1, tracks)
    },
    findByName: function findByName(objectOrClipArray, name) {
      var clipArray = objectOrClipArray

      if (!Array.isArray(objectOrClipArray)) {
        var o = objectOrClipArray
        clipArray = (o.geometry && o.geometry.animations) || o.animations
      }

      for (var i = 0; i < clipArray.length; i++) {
        if (clipArray[i].name === name) {
          return clipArray[i]
        }
      }

      return null
    },
    CreateClipsFromMorphTargetSequences: function CreateClipsFromMorphTargetSequences(morphTargets, fps, noLoop) {
      var animationToMorphTargets = {} // tested with https://regex101.com/ on trick sequences
      // such flamingo_flyA_003, flamingo_run1_003, crdeath0059

      var pattern = /^([\w-]*?)([\d]+)$/ // sort morph target names into animation groups based
      // patterns like Walk_001, Walk_002, Run_001, Run_002

      for (var i = 0, il = morphTargets.length; i < il; i++) {
        var morphTarget = morphTargets[i]
        var parts = morphTarget.name.match(pattern)

        if (parts && parts.length > 1) {
          var name = parts[1]
          var animationMorphTargets = animationToMorphTargets[name]

          if (!animationMorphTargets) {
            animationToMorphTargets[name] = animationMorphTargets = []
          }

          animationMorphTargets.push(morphTarget)
        }
      }

      var clips = []

      for (var _name in animationToMorphTargets) {
        clips.push(AnimationClip.CreateFromMorphTargetSequence(_name, animationToMorphTargets[_name], fps, noLoop))
      }

      return clips
    },
    // parse the animation.hierarchy format
    parseAnimation: function parseAnimation(animation, bones) {
      if (!animation) {
        console.error('THREE.AnimationClip: No animation in JSONLoader data.')
        return null
      }

      var addNonemptyTrack = function addNonemptyTrack(trackType, trackName, animationKeys, propertyName, destTracks) {
        // only return track if there are actually keys.
        if (animationKeys.length !== 0) {
          var times = []
          var values = []
          AnimationUtils.flattenJSON(animationKeys, times, values, propertyName) // empty keys are filtered out, so check again

          if (times.length !== 0) {
            destTracks.push(new trackType(trackName, times, values))
          }
        }
      }

      var tracks = []
      var clipName = animation.name || 'default'
      var fps = animation.fps || 30
      var blendMode = animation.blendMode // automatic length determination in AnimationClip.

      var duration = animation.length || -1
      var hierarchyTracks = animation.hierarchy || []

      for (var h = 0; h < hierarchyTracks.length; h++) {
        var 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
          var morphTargetNames = {}
          var k = void 0

          for (k = 0; k < animationKeys.length; k++) {
            if (animationKeys[k].morphTargets) {
              for (var 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 (var morphTargetName in morphTargetNames) {
            var times = []
            var values = []

            for (var _m = 0; _m !== animationKeys[k].morphTargets.length; ++_m) {
              var animationKey = animationKeys[k]
              times.push(animationKey.time)
              values.push(animationKey.morphTarget === morphTargetName ? 1 : 0)
            }

            tracks.push(new NumberKeyframeTrack('.morphTargetInfluence[' + morphTargetName + ']', times, values))
          }

          duration = morphTargetNames.length * (fps || 1.0)
        } else {
          // ...assume skeletal animation
          var boneName = '.bones[' + bones[h].name + ']'
          addNonemptyTrack(VectorKeyframeTrack, boneName + '.position', animationKeys, 'pos', tracks)
          addNonemptyTrack(QuaternionKeyframeTrack, boneName + '.quaternion', animationKeys, 'rot', tracks)
          addNonemptyTrack(VectorKeyframeTrack, boneName + '.scale', animationKeys, 'scl', tracks)
        }
      }

      if (tracks.length === 0) {
        return null
      }

      var clip = new AnimationClip(clipName, duration, tracks, blendMode)
      return clip
    }
  })
  Object.assign(AnimationClip.prototype, {
    resetDuration: function resetDuration() {
      var tracks = this.tracks
      var duration = 0

      for (var i = 0, n = tracks.length; i !== n; ++i) {
        var track = this.tracks[i]
        duration = Math.max(duration, track.times[track.times.length - 1])
      }

      this.duration = duration
      return this
    },
    trim: function trim() {
      for (var i = 0; i < this.tracks.length; i++) {
        this.tracks[i].trim(0, this.duration)
      }

      return this
    },
    validate: function validate() {
      var valid = true

      for (var i = 0; i < this.tracks.length; i++) {
        valid = valid && this.tracks[i].validate()
      }

      return valid
    },
    optimize: function optimize() {
      for (var i = 0; i < this.tracks.length; i++) {
        this.tracks[i].optimize()
      }

      return this
    },
    clone: function clone() {
      var tracks = []

      for (var i = 0; i < this.tracks.length; i++) {
        tracks.push(this.tracks[i].clone())
      }

      return new AnimationClip(this.name, this.duration, tracks, this.blendMode)
    },
    toJSON: function toJSON() {
      return AnimationClip.toJSON(this)
    }
  })

  var Cache = {
    enabled: false,
    files: {},
    add: function add(key, file) {
      if (this.enabled === false) return // console.log( 'THREE.Cache', 'Adding key:', key );

      this.files[key] = file
    },
    get: function get(key) {
      if (this.enabled === false) return // console.log( 'THREE.Cache', 'Checking key:', key );

      return this.files[key]
    },
    remove: function remove(key) {
      delete this.files[key]
    },
    clear: function clear() {
      this.files = {}
    }
  }

  function LoadingManager(onLoad, onProgress, onError) {
    var scope = this
    var isLoading = false
    var itemsLoaded = 0
    var itemsTotal = 0
    var urlModifier = undefined
    var 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) {
      var index = handlers.indexOf(regex)

      if (index !== -1) {
        handlers.splice(index, 2)
      }

      return this
    }

    this.getHandler = function (file) {
      for (var i = 0, l = handlers.length; i < l; i += 2) {
        var regex = handlers[i]
        var loader = handlers[i + 1]
        if (regex.global) regex.lastIndex = 0 // see #17920

        if (regex.test(file)) {
          return loader
        }
      }

      return null
    }
  }

  var DefaultLoadingManager = new LoadingManager()

  function Loader(manager) {
    this.manager = manager !== undefined ? manager : DefaultLoadingManager
    this.crossOrigin = 'anonymous'
    this.withCredentials = false
    this.path = ''
    this.resourcePath = ''
    this.requestHeader = {}
  }

  Object.assign(Loader.prototype, {
    load: function load() /* url, onLoad, onProgress, onError */
    {},
    loadAsync: function loadAsync(url, onProgress) {
      var scope = this
      return new Promise(function (resolve, reject) {
        scope.load(url, resolve, onProgress, reject)
      })
    },
    parse: function parse() /* data */
    {},
    setCrossOrigin: function setCrossOrigin(crossOrigin) {
      this.crossOrigin = crossOrigin
      return this
    },
    setWithCredentials: function setWithCredentials(value) {
      this.withCredentials = value
      return this
    },
    setPath: function setPath(path) {
      this.path = path
      return this
    },
    setResourcePath: function setResourcePath(resourcePath) {
      this.resourcePath = resourcePath
      return this
    },
    setRequestHeader: function setRequestHeader(requestHeader) {
      this.requestHeader = requestHeader
      return this
    }
  })

  var loading = {}

  function FileLoader(manager) {
    Loader.call(this, manager)
  }

  FileLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: FileLoader,
    load: function load(url, onLoad, onProgress, onError) {
      if (url === undefined) url = ''
      if (this.path !== undefined) url = this.path + url
      url = this.manager.resolveURL(url)
      var scope = this
      var cached = Cache.get(url)

      if (cached !== undefined) {
        scope.manager.itemStart(url)
        setTimeout(function () {
          if (onLoad) onLoad(cached)
          scope.manager.itemEnd(url)
        }, 0)
        return cached
      } // Check if request is duplicate

      if (loading[url] !== undefined) {
        loading[url].push({
          onLoad: onLoad,
          onProgress: onProgress,
          onError: onError
        })
        return
      } // Check for data: URI

      var dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/
      var dataUriRegexResult = url.match(dataUriRegex)
      var request // Safari can not handle Data URIs through XMLHttpRequest so process manually

      if (dataUriRegexResult) {
        var mimeType = dataUriRegexResult[1]
        var isBase64 = !!dataUriRegexResult[2]
        var data = dataUriRegexResult[3]
        data = decodeURIComponent(data)
        if (isBase64) data = atob(data)

        try {
          var response
          var responseType = (this.responseType || '').toLowerCase()

          switch (responseType) {
            case 'arraybuffer':
            case 'blob':
              var view = new Uint8Array(data.length)

              for (var i = 0; i < data.length; i++) {
                view[i] = data.charCodeAt(i)
              }

              if (responseType === 'blob') {
                response = new Blob([view.buffer], {
                  type: mimeType
                })
              } else {
                response = view.buffer
              }

              break

            case 'document':
              var parser = new DOMParser()
              response = parser.parseFromString(data, mimeType)
              break

            case 'json':
              response = JSON.parse(data)
              break

            default:
              // 'text' or other
              response = data
              break
          } // Wait for next browser tick like standard XMLHttpRequest event dispatching does

          setTimeout(function () {
            if (onLoad) onLoad(response)
            scope.manager.itemEnd(url)
          }, 0)
        } catch (error) {
          // Wait for next browser tick like standard XMLHttpRequest event dispatching does
          setTimeout(function () {
            if (onError) onError(error)
            scope.manager.itemError(url)
            scope.manager.itemEnd(url)
          }, 0)
        }
      } else {
        // Initialise array for duplicate requests
        loading[url] = []
        loading[url].push({
          onLoad: onLoad,
          onProgress: onProgress,
          onError: onError
        })
        request = new XMLHttpRequest()
        request.open('GET', url, true)
        request.addEventListener(
          'load',
          function (event) {
            var response = this.response
            var callbacks = loading[url]
            delete loading[url]

            if (this.status === 200 || this.status === 0) {
              // Some browsers return HTTP Status 0 when using non-http protocol
              // e.g. 'file://' or 'data://'. Handle as success.
              if (this.status === 0) console.warn('THREE.FileLoader: HTTP Status 0 received.') // Add to cache only on HTTP success, so that we do not cache
              // error response bodies as proper responses to requests.

              Cache.add(url, response)

              for (var _i = 0, il = callbacks.length; _i < il; _i++) {
                var callback = callbacks[_i]
                if (callback.onLoad) callback.onLoad(response)
              }

              scope.manager.itemEnd(url)
            } else {
              for (var _i2 = 0, _il = callbacks.length; _i2 < _il; _i2++) {
                var _callback = callbacks[_i2]
                if (_callback.onError) _callback.onError(event)
              }

              scope.manager.itemError(url)
              scope.manager.itemEnd(url)
            }
          },
          false
        )
        request.addEventListener(
          'progress',
          function (event) {
            var callbacks = loading[url]

            for (var _i3 = 0, il = callbacks.length; _i3 < il; _i3++) {
              var callback = callbacks[_i3]
              if (callback.onProgress) callback.onProgress(event)
            }
          },
          false
        )
        request.addEventListener(
          'error',
          function (event) {
            var callbacks = loading[url]
            delete loading[url]

            for (var _i4 = 0, il = callbacks.length; _i4 < il; _i4++) {
              var callback = callbacks[_i4]
              if (callback.onError) callback.onError(event)
            }

            scope.manager.itemError(url)
            scope.manager.itemEnd(url)
          },
          false
        )
        request.addEventListener(
          'abort',
          function (event) {
            var callbacks = loading[url]
            delete loading[url]

            for (var _i5 = 0, il = callbacks.length; _i5 < il; _i5++) {
              var callback = callbacks[_i5]
              if (callback.onError) callback.onError(event)
            }

            scope.manager.itemError(url)
            scope.manager.itemEnd(url)
          },
          false
        )
        if (this.responseType !== undefined) request.responseType = this.responseType
        if (this.withCredentials !== undefined) request.withCredentials = this.withCredentials
        if (request.overrideMimeType) request.overrideMimeType(this.mimeType !== undefined ? this.mimeType : 'text/plain')

        for (var header in this.requestHeader) {
          request.setRequestHeader(header, this.requestHeader[header])
        }

        request.send(null)
      }

      scope.manager.itemStart(url)
      return request
    },
    setResponseType: function setResponseType(value) {
      this.responseType = value
      return this
    },
    setMimeType: function setMimeType(value) {
      this.mimeType = value
      return this
    }
  })

  function AnimationLoader(manager) {
    Loader.call(this, manager)
  }

  AnimationLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: AnimationLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var loader = new FileLoader(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: function parse(json) {
      var animations = []

      for (var i = 0; i < json.length; i++) {
        var clip = AnimationClip.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().
   */

  function CompressedTextureLoader(manager) {
    Loader.call(this, manager)
  }

  CompressedTextureLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: CompressedTextureLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var images = []
      var texture = new CompressedTexture()
      var loader = new FileLoader(this.manager)
      loader.setPath(this.path)
      loader.setResponseType('arraybuffer')
      loader.setRequestHeader(this.requestHeader)
      loader.setWithCredentials(scope.withCredentials)
      var loaded = 0

      function loadTexture(i) {
        loader.load(
          url[i],
          function (buffer) {
            var 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 = LinearFilter
              texture.image = images
              texture.format = texDatas.format
              texture.needsUpdate = true
              if (onLoad) onLoad(texture)
            }
          },
          onProgress,
          onError
        )
      }

      if (Array.isArray(url)) {
        for (var 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) {
            var texDatas = scope.parse(buffer, true)

            if (texDatas.isCubemap) {
              var faces = texDatas.mipmaps.length / texDatas.mipmapCount

              for (var f = 0; f < faces; f++) {
                images[f] = {
                  mipmaps: []
                }

                for (var _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 = LinearFilter
            }

            texture.format = texDatas.format
            texture.needsUpdate = true
            if (onLoad) onLoad(texture)
          },
          onProgress,
          onError
        )
      }

      return texture
    }
  })

  function ImageLoader(manager) {
    Loader.call(this, manager)
  }

  ImageLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: ImageLoader,
    load: function load(url, onLoad, onProgress, onError) {
      if (this.path !== undefined) url = this.path + url
      url = this.manager.resolveURL(url)
      var scope = this
      var cached = Cache.get(url)

      if (cached !== undefined) {
        scope.manager.itemStart(url)
        setTimeout(function () {
          if (onLoad) onLoad(cached)
          scope.manager.itemEnd(url)
        }, 0)
        return cached
      }

      var image = document.createElementNS('http://www.w3.org/1999/xhtml', 'img')

      function onImageLoad() {
        image.removeEventListener('load', onImageLoad, false)
        image.removeEventListener('error', onImageError, false)
        Cache.add(url, this)
        if (onLoad) onLoad(this)
        scope.manager.itemEnd(url)
      }

      function onImageError(event) {
        image.removeEventListener('load', onImageLoad, false)
        image.removeEventListener('error', onImageError, false)
        if (onError) onError(event)
        scope.manager.itemError(url)
        scope.manager.itemEnd(url)
      }

      image.addEventListener('load', onImageLoad, false)
      image.addEventListener('error', onImageError, false)

      if (url.substr(0, 5) !== 'data:') {
        if (this.crossOrigin !== undefined) image.crossOrigin = this.crossOrigin
      }

      scope.manager.itemStart(url)
      image.src = url
      return image
    }
  })

  function CubeTextureLoader(manager) {
    Loader.call(this, manager)
  }

  CubeTextureLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: CubeTextureLoader,
    load: function load(urls, onLoad, onProgress, onError) {
      var texture = new CubeTexture()
      var loader = new ImageLoader(this.manager)
      loader.setCrossOrigin(this.crossOrigin)
      loader.setPath(this.path)
      var 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 (var 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().
   */

  function DataTextureLoader(manager) {
    Loader.call(this, manager)
  }

  DataTextureLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: DataTextureLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var texture = new DataTexture()
      var loader = new FileLoader(this.manager)
      loader.setResponseType('arraybuffer')
      loader.setRequestHeader(this.requestHeader)
      loader.setPath(this.path)
      loader.setWithCredentials(scope.withCredentials)
      loader.load(
        url,
        function (buffer) {
          var texData = scope.parse(buffer)
          if (!texData) 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 : ClampToEdgeWrapping
          texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : ClampToEdgeWrapping
          texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : LinearFilter
          texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : LinearFilter
          texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1

          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 = LinearMipmapLinearFilter // presumably...
          }

          if (texData.mipmapCount === 1) {
            texture.minFilter = LinearFilter
          }

          texture.needsUpdate = true
          if (onLoad) onLoad(texture, texData)
        },
        onProgress,
        onError
      )
      return texture
    }
  })

  function TextureLoader(manager) {
    Loader.call(this, manager)
  }

  TextureLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: TextureLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var texture = new Texture()
      var loader = new ImageLoader(this.manager)
      loader.setCrossOrigin(this.crossOrigin)
      loader.setPath(this.path)
      loader.load(
        url,
        function (image) {
          texture.image = image // JPEGs can't have an alpha channel, so memory can be saved by storing them as RGB.

          var isJPEG = url.search(/\.jpe?g($|\?)/i) > 0 || url.search(/^data\:image\/jpeg/) === 0
          texture.format = isJPEG ? RGBFormat : RGBAFormat
          texture.needsUpdate = true

          if (onLoad !== undefined) {
            onLoad(texture)
          }
        },
        onProgress,
        onError
      )
      return texture
    }
  })

  /**
   * 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.
   *
   **/

  function Curve() {
    this.type = 'Curve'
    this.arcLengthDivisions = 200
  }

  Object.assign(Curve.prototype, {
    // Virtual base class method to overwrite and implement in subclasses
    //	- t [0 .. 1]
    getPoint: function getPoint() /* t, optionalTarget */
    {
      console.warn('THREE.Curve: .getPoint() not implemented.')
      return null
    },
    // Get point at relative position in curve according to arc length
    // - u [0 .. 1]
    getPointAt: function getPointAt(u, optionalTarget) {
      var t = this.getUtoTmapping(u)
      return this.getPoint(t, optionalTarget)
    },
    // Get sequence of points using getPoint( t )
    getPoints: function getPoints(divisions) {
      if (divisions === void 0) {
        divisions = 5
      }

      var points = []

      for (var d = 0; d <= divisions; d++) {
        points.push(this.getPoint(d / divisions))
      }

      return points
    },
    // Get sequence of points using getPointAt( u )
    getSpacedPoints: function getSpacedPoints(divisions) {
      if (divisions === void 0) {
        divisions = 5
      }

      var points = []

      for (var d = 0; d <= divisions; d++) {
        points.push(this.getPointAt(d / divisions))
      }

      return points
    },
    // Get total curve arc length
    getLength: function getLength() {
      var lengths = this.getLengths()
      return lengths[lengths.length - 1]
    },
    // Get list of cumulative segment lengths
    getLengths: function getLengths(divisions) {
      if (divisions === undefined) divisions = this.arcLengthDivisions

      if (this.cacheArcLengths && this.cacheArcLengths.length === divisions + 1 && !this.needsUpdate) {
        return this.cacheArcLengths
      }

      this.needsUpdate = false
      var cache = []
      var current,
        last = this.getPoint(0)
      var sum = 0
      cache.push(0)

      for (var 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: function updateArcLengths() {
      this.needsUpdate = true
      this.getLengths()
    },
    // Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
    getUtoTmapping: function getUtoTmapping(u, distance) {
      var arcLengths = this.getLengths()
      var i = 0
      var il = arcLengths.length
      var 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

      var 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

      var lengthBefore = arcLengths[i]
      var lengthAfter = arcLengths[i + 1]
      var segmentLength = lengthAfter - lengthBefore // determine where we are between the 'before' and 'after' points

      var segmentFraction = (targetArcLength - lengthBefore) / segmentLength // add that fractional amount to t

      var 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: function getTangent(t, optionalTarget) {
      var delta = 0.0001
      var t1 = t - delta
      var t2 = t + delta // Capping in case of danger

      if (t1 < 0) t1 = 0
      if (t2 > 1) t2 = 1
      var pt1 = this.getPoint(t1)
      var pt2 = this.getPoint(t2)
      var tangent = optionalTarget || (pt1.isVector2 ? new Vector2() : new Vector3())
      tangent.copy(pt2).sub(pt1).normalize()
      return tangent
    },
    getTangentAt: function getTangentAt(u, optionalTarget) {
      var t = this.getUtoTmapping(u)
      return this.getTangent(t, optionalTarget)
    },
    computeFrenetFrames: function computeFrenetFrames(segments, closed) {
      // see http://www.cs.indiana.edu/pub/techreports/TR425.pdf
      var normal = new Vector3()
      var tangents = []
      var normals = []
      var binormals = []
      var vec = new Vector3()
      var mat = new Matrix4() // compute the tangent vectors for each segment on the curve

      for (var i = 0; i <= segments; i++) {
        var u = i / segments
        tangents[i] = this.getTangentAt(u, new Vector3())
        tangents[i].normalize()
      } // select an initial normal vector perpendicular to the first tangent vector,
      // and in the direction of the minimum tangent xyz component

      normals[0] = new Vector3()
      binormals[0] = new Vector3()
      var min = Number.MAX_VALUE
      var tx = Math.abs(tangents[0].x)
      var ty = Math.abs(tangents[0].y)
      var 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 (var _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()
          var theta = Math.acos(MathUtils.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) {
        var _theta = Math.acos(MathUtils.clamp(normals[0].dot(normals[segments]), -1, 1))

        _theta /= segments

        if (tangents[0].dot(vec.crossVectors(normals[0], normals[segments])) > 0) {
          _theta = -_theta
        }

        for (var _i2 = 1; _i2 <= segments; _i2++) {
          // twist a little...
          normals[_i2].applyMatrix4(mat.makeRotationAxis(tangents[_i2], _theta * _i2))

          binormals[_i2].crossVectors(tangents[_i2], normals[_i2])
        }
      }

      return {
        tangents: tangents,
        normals: normals,
        binormals: binormals
      }
    },
    clone: function clone() {
      return new this.constructor().copy(this)
    },
    copy: function copy(source) {
      this.arcLengthDivisions = source.arcLengthDivisions
      return this
    },
    toJSON: function toJSON() {
      var data = {
        metadata: {
          version: 4.5,
          type: 'Curve',
          generator: 'Curve.toJSON'
        }
      }
      data.arcLengthDivisions = this.arcLengthDivisions
      data.type = this.type
      return data
    },
    fromJSON: function fromJSON(json) {
      this.arcLengthDivisions = json.arcLengthDivisions
      return this
    }
  })

  function EllipseCurve(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
    Curve.call(this)
    this.type = 'EllipseCurve'
    this.aX = aX || 0
    this.aY = aY || 0
    this.xRadius = xRadius || 1
    this.yRadius = yRadius || 1
    this.aStartAngle = aStartAngle || 0
    this.aEndAngle = aEndAngle || 2 * Math.PI
    this.aClockwise = aClockwise || false
    this.aRotation = aRotation || 0
  }

  EllipseCurve.prototype = Object.create(Curve.prototype)
  EllipseCurve.prototype.constructor = EllipseCurve
  EllipseCurve.prototype.isEllipseCurve = true

  EllipseCurve.prototype.getPoint = function (t, optionalTarget) {
    var point = optionalTarget || new Vector2()
    var twoPi = Math.PI * 2
    var deltaAngle = this.aEndAngle - this.aStartAngle
    var 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
      }
    }

    var angle = this.aStartAngle + t * deltaAngle
    var x = this.aX + this.xRadius * Math.cos(angle)
    var y = this.aY + this.yRadius * Math.sin(angle)

    if (this.aRotation !== 0) {
      var cos = Math.cos(this.aRotation)
      var sin = Math.sin(this.aRotation)
      var tx = x - this.aX
      var 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)
  }

  EllipseCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, 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
  }

  EllipseCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    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
  }

  EllipseCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, 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
  }

  function ArcCurve(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
    EllipseCurve.call(this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise)
    this.type = 'ArcCurve'
  }

  ArcCurve.prototype = Object.create(EllipseCurve.prototype)
  ArcCurve.prototype.constructor = ArcCurve
  ArcCurve.prototype.isArcCurve = true

  /**
   * 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 CubicPoly() {
    var 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 initCatmullRom(x0, x1, x2, x3, tension) {
        init(x1, x2, tension * (x2 - x0), tension * (x3 - x1))
      },
      initNonuniformCatmullRom: function initNonuniformCatmullRom(x0, x1, x2, x3, dt0, dt1, dt2) {
        // compute tangents when parameterized in [t1,t2]
        var t1 = (x1 - x0) / dt0 - (x2 - x0) / (dt0 + dt1) + (x2 - x1) / dt1
        var 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 calc(t) {
        var t2 = t * t
        var t3 = t2 * t
        return c0 + c1 * t + c2 * t2 + c3 * t3
      }
    }
  } //

  var tmp = new Vector3()
  var px = new CubicPoly(),
    py = new CubicPoly(),
    pz = new CubicPoly()

  function CatmullRomCurve3(points, closed, curveType, tension) {
    if (points === void 0) {
      points = []
    }

    if (closed === void 0) {
      closed = false
    }

    if (curveType === void 0) {
      curveType = 'centripetal'
    }

    if (tension === void 0) {
      tension = 0.5
    }

    Curve.call(this)
    this.type = 'CatmullRomCurve3'
    this.points = points
    this.closed = closed
    this.curveType = curveType
    this.tension = tension
  }

  CatmullRomCurve3.prototype = Object.create(Curve.prototype)
  CatmullRomCurve3.prototype.constructor = CatmullRomCurve3
  CatmullRomCurve3.prototype.isCatmullRomCurve3 = true

  CatmullRomCurve3.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector3()
    }

    var point = optionalTarget
    var points = this.points
    var l = points.length
    var p = (l - (this.closed ? 0 : 1)) * t
    var intPoint = Math.floor(p)
    var 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
    }

    var p0, p3 // 4 points (p1 & p2 defined below)

    if (this.closed || intPoint > 0) {
      p0 = points[(intPoint - 1) % l]
    } else {
      // extrapolate first point
      tmp.subVectors(points[0], points[1]).add(points[0])
      p0 = tmp
    }

    var p1 = points[intPoint % l]
    var p2 = points[(intPoint + 1) % l]

    if (this.closed || intPoint + 2 < l) {
      p3 = points[(intPoint + 2) % l]
    } else {
      // extrapolate last point
      tmp.subVectors(points[l - 1], points[l - 2]).add(points[l - 1])
      p3 = tmp
    }

    if (this.curveType === 'centripetal' || this.curveType === 'chordal') {
      // init Centripetal / Chordal Catmull-Rom
      var pow = this.curveType === 'chordal' ? 0.5 : 0.25
      var dt0 = Math.pow(p0.distanceToSquared(p1), pow)
      var dt1 = Math.pow(p1.distanceToSquared(p2), pow)
      var 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
      px.initNonuniformCatmullRom(p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2)
      py.initNonuniformCatmullRom(p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2)
      pz.initNonuniformCatmullRom(p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2)
    } else if (this.curveType === 'catmullrom') {
      px.initCatmullRom(p0.x, p1.x, p2.x, p3.x, this.tension)
      py.initCatmullRom(p0.y, p1.y, p2.y, p3.y, this.tension)
      pz.initCatmullRom(p0.z, p1.z, p2.z, p3.z, this.tension)
    }

    point.set(px.calc(weight), py.calc(weight), pz.calc(weight))
    return point
  }

  CatmullRomCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.points = []

    for (var i = 0, l = source.points.length; i < l; i++) {
      var point = source.points[i]
      this.points.push(point.clone())
    }

    this.closed = source.closed
    this.curveType = source.curveType
    this.tension = source.tension
    return this
  }

  CatmullRomCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.points = []

    for (var i = 0, l = this.points.length; i < l; i++) {
      var point = this.points[i]
      data.points.push(point.toArray())
    }

    data.closed = this.closed
    data.curveType = this.curveType
    data.tension = this.tension
    return data
  }

  CatmullRomCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.points = []

    for (var i = 0, l = json.points.length; i < l; i++) {
      var point = json.points[i]
      this.points.push(new Vector3().fromArray(point))
    }

    this.closed = json.closed
    this.curveType = json.curveType
    this.tension = json.tension
    return this
  }

  /**
   * Bezier Curves formulas obtained from
   * http://en.wikipedia.org/wiki/Bézier_curve
   */
  function CatmullRom(t, p0, p1, p2, p3) {
    var v0 = (p2 - p0) * 0.5
    var v1 = (p3 - p1) * 0.5
    var t2 = t * t
    var t3 = t * t2
    return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1
  } //

  function QuadraticBezierP0(t, p) {
    var k = 1 - t
    return k * k * p
  }

  function QuadraticBezierP1(t, p) {
    return 2 * (1 - t) * t * p
  }

  function QuadraticBezierP2(t, p) {
    return t * t * p
  }

  function QuadraticBezier(t, p0, p1, p2) {
    return QuadraticBezierP0(t, p0) + QuadraticBezierP1(t, p1) + QuadraticBezierP2(t, p2)
  } //

  function CubicBezierP0(t, p) {
    var k = 1 - t
    return k * k * k * p
  }

  function CubicBezierP1(t, p) {
    var k = 1 - t
    return 3 * k * k * t * p
  }

  function CubicBezierP2(t, p) {
    return 3 * (1 - t) * t * t * p
  }

  function CubicBezierP3(t, p) {
    return t * t * t * p
  }

  function CubicBezier(t, p0, p1, p2, p3) {
    return CubicBezierP0(t, p0) + CubicBezierP1(t, p1) + CubicBezierP2(t, p2) + CubicBezierP3(t, p3)
  }

  function CubicBezierCurve(v0, v1, v2, v3) {
    if (v0 === void 0) {
      v0 = new Vector2()
    }

    if (v1 === void 0) {
      v1 = new Vector2()
    }

    if (v2 === void 0) {
      v2 = new Vector2()
    }

    if (v3 === void 0) {
      v3 = new Vector2()
    }

    Curve.call(this)
    this.type = 'CubicBezierCurve'
    this.v0 = v0
    this.v1 = v1
    this.v2 = v2
    this.v3 = v3
  }

  CubicBezierCurve.prototype = Object.create(Curve.prototype)
  CubicBezierCurve.prototype.constructor = CubicBezierCurve
  CubicBezierCurve.prototype.isCubicBezierCurve = true

  CubicBezierCurve.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector2()
    }

    var point = optionalTarget
    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2,
      v3 = this.v3
    point.set(CubicBezier(t, v0.x, v1.x, v2.x, v3.x), CubicBezier(t, v0.y, v1.y, v2.y, v3.y))
    return point
  }

  CubicBezierCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    this.v3.copy(source.v3)
    return this
  }

  CubicBezierCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    data.v3 = this.v3.toArray()
    return data
  }

  CubicBezierCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    this.v3.fromArray(json.v3)
    return this
  }

  function CubicBezierCurve3(v0, v1, v2, v3) {
    if (v0 === void 0) {
      v0 = new Vector3()
    }

    if (v1 === void 0) {
      v1 = new Vector3()
    }

    if (v2 === void 0) {
      v2 = new Vector3()
    }

    if (v3 === void 0) {
      v3 = new Vector3()
    }

    Curve.call(this)
    this.type = 'CubicBezierCurve3'
    this.v0 = v0
    this.v1 = v1
    this.v2 = v2
    this.v3 = v3
  }

  CubicBezierCurve3.prototype = Object.create(Curve.prototype)
  CubicBezierCurve3.prototype.constructor = CubicBezierCurve3
  CubicBezierCurve3.prototype.isCubicBezierCurve3 = true

  CubicBezierCurve3.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector3()
    }

    var point = optionalTarget
    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2,
      v3 = this.v3
    point.set(CubicBezier(t, v0.x, v1.x, v2.x, v3.x), CubicBezier(t, v0.y, v1.y, v2.y, v3.y), CubicBezier(t, v0.z, v1.z, v2.z, v3.z))
    return point
  }

  CubicBezierCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    this.v3.copy(source.v3)
    return this
  }

  CubicBezierCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    data.v3 = this.v3.toArray()
    return data
  }

  CubicBezierCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    this.v3.fromArray(json.v3)
    return this
  }

  function LineCurve(v1, v2) {
    if (v1 === void 0) {
      v1 = new Vector2()
    }

    if (v2 === void 0) {
      v2 = new Vector2()
    }

    Curve.call(this)
    this.type = 'LineCurve'
    this.v1 = v1
    this.v2 = v2
  }

  LineCurve.prototype = Object.create(Curve.prototype)
  LineCurve.prototype.constructor = LineCurve
  LineCurve.prototype.isLineCurve = true

  LineCurve.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector2()
    }

    var 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

  LineCurve.prototype.getPointAt = function (u, optionalTarget) {
    return this.getPoint(u, optionalTarget)
  }

  LineCurve.prototype.getTangent = function (t, optionalTarget) {
    var tangent = optionalTarget || new Vector2()
    tangent.copy(this.v2).sub(this.v1).normalize()
    return tangent
  }

  LineCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    return this
  }

  LineCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    return data
  }

  LineCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    return this
  }

  function LineCurve3(v1, v2) {
    if (v1 === void 0) {
      v1 = new Vector3()
    }

    if (v2 === void 0) {
      v2 = new Vector3()
    }

    Curve.call(this)
    this.type = 'LineCurve3'
    this.v1 = v1
    this.v2 = v2
  }

  LineCurve3.prototype = Object.create(Curve.prototype)
  LineCurve3.prototype.constructor = LineCurve3
  LineCurve3.prototype.isLineCurve3 = true

  LineCurve3.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector3()
    }

    var 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

  LineCurve3.prototype.getPointAt = function (u, optionalTarget) {
    return this.getPoint(u, optionalTarget)
  }

  LineCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    return this
  }

  LineCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    return data
  }

  LineCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    return this
  }

  function QuadraticBezierCurve(v0, v1, v2) {
    if (v0 === void 0) {
      v0 = new Vector2()
    }

    if (v1 === void 0) {
      v1 = new Vector2()
    }

    if (v2 === void 0) {
      v2 = new Vector2()
    }

    Curve.call(this)
    this.type = 'QuadraticBezierCurve'
    this.v0 = v0
    this.v1 = v1
    this.v2 = v2
  }

  QuadraticBezierCurve.prototype = Object.create(Curve.prototype)
  QuadraticBezierCurve.prototype.constructor = QuadraticBezierCurve
  QuadraticBezierCurve.prototype.isQuadraticBezierCurve = true

  QuadraticBezierCurve.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector2()
    }

    var point = optionalTarget
    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2
    point.set(QuadraticBezier(t, v0.x, v1.x, v2.x), QuadraticBezier(t, v0.y, v1.y, v2.y))
    return point
  }

  QuadraticBezierCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    return this
  }

  QuadraticBezierCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    return data
  }

  QuadraticBezierCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    return this
  }

  function QuadraticBezierCurve3(v0, v1, v2) {
    if (v0 === void 0) {
      v0 = new Vector3()
    }

    if (v1 === void 0) {
      v1 = new Vector3()
    }

    if (v2 === void 0) {
      v2 = new Vector3()
    }

    Curve.call(this)
    this.type = 'QuadraticBezierCurve3'
    this.v0 = v0
    this.v1 = v1
    this.v2 = v2
  }

  QuadraticBezierCurve3.prototype = Object.create(Curve.prototype)
  QuadraticBezierCurve3.prototype.constructor = QuadraticBezierCurve3
  QuadraticBezierCurve3.prototype.isQuadraticBezierCurve3 = true

  QuadraticBezierCurve3.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector3()
    }

    var point = optionalTarget
    var v0 = this.v0,
      v1 = this.v1,
      v2 = this.v2
    point.set(QuadraticBezier(t, v0.x, v1.x, v2.x), QuadraticBezier(t, v0.y, v1.y, v2.y), QuadraticBezier(t, v0.z, v1.z, v2.z))
    return point
  }

  QuadraticBezierCurve3.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.v0.copy(source.v0)
    this.v1.copy(source.v1)
    this.v2.copy(source.v2)
    return this
  }

  QuadraticBezierCurve3.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.v0 = this.v0.toArray()
    data.v1 = this.v1.toArray()
    data.v2 = this.v2.toArray()
    return data
  }

  QuadraticBezierCurve3.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.v0.fromArray(json.v0)
    this.v1.fromArray(json.v1)
    this.v2.fromArray(json.v2)
    return this
  }

  function SplineCurve(points) {
    if (points === void 0) {
      points = []
    }

    Curve.call(this)
    this.type = 'SplineCurve'
    this.points = points
  }

  SplineCurve.prototype = Object.create(Curve.prototype)
  SplineCurve.prototype.constructor = SplineCurve
  SplineCurve.prototype.isSplineCurve = true

  SplineCurve.prototype.getPoint = function (t, optionalTarget) {
    if (optionalTarget === void 0) {
      optionalTarget = new Vector2()
    }

    var point = optionalTarget
    var points = this.points
    var p = (points.length - 1) * t
    var intPoint = Math.floor(p)
    var weight = p - intPoint
    var p0 = points[intPoint === 0 ? intPoint : intPoint - 1]
    var p1 = points[intPoint]
    var p2 = points[intPoint > points.length - 2 ? points.length - 1 : intPoint + 1]
    var p3 = points[intPoint > points.length - 3 ? points.length - 1 : intPoint + 2]
    point.set(CatmullRom(weight, p0.x, p1.x, p2.x, p3.x), CatmullRom(weight, p0.y, p1.y, p2.y, p3.y))
    return point
  }

  SplineCurve.prototype.copy = function (source) {
    Curve.prototype.copy.call(this, source)
    this.points = []

    for (var i = 0, l = source.points.length; i < l; i++) {
      var point = source.points[i]
      this.points.push(point.clone())
    }

    return this
  }

  SplineCurve.prototype.toJSON = function () {
    var data = Curve.prototype.toJSON.call(this)
    data.points = []

    for (var i = 0, l = this.points.length; i < l; i++) {
      var point = this.points[i]
      data.points.push(point.toArray())
    }

    return data
  }

  SplineCurve.prototype.fromJSON = function (json) {
    Curve.prototype.fromJSON.call(this, json)
    this.points = []

    for (var i = 0, l = json.points.length; i < l; i++) {
      var point = json.points[i]
      this.points.push(new Vector2().fromArray(point))
    }

    return this
  }

  var Curves = /*#__PURE__*/ Object.freeze({
    __proto__: null,
    ArcCurve: ArcCurve,
    CatmullRomCurve3: CatmullRomCurve3,
    CubicBezierCurve: CubicBezierCurve,
    CubicBezierCurve3: CubicBezierCurve3,
    EllipseCurve: EllipseCurve,
    LineCurve: LineCurve,
    LineCurve3: LineCurve3,
    QuadraticBezierCurve: QuadraticBezierCurve,
    QuadraticBezierCurve3: QuadraticBezierCurve3,
    SplineCurve: SplineCurve
  })

  /**************************************************************
   *	Curved Path - a curve path is simply a array of connected
   *	curves, but retains the api of a curve
   **************************************************************/

  function CurvePath() {
    Curve.call(this)
    this.type = 'CurvePath'
    this.curves = []
    this.autoClose = false // Automatically closes the path
  }

  CurvePath.prototype = Object.assign(Object.create(Curve.prototype), {
    constructor: CurvePath,
    add: function add(curve) {
      this.curves.push(curve)
    },
    closePath: function closePath() {
      // Add a line curve if start and end of lines are not connected
      var startPoint = this.curves[0].getPoint(0)
      var endPoint = this.curves[this.curves.length - 1].getPoint(1)

      if (!startPoint.equals(endPoint)) {
        this.curves.push(new LineCurve(endPoint, startPoint))
      }
    },
    // 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: function getPoint(t) {
      var d = t * this.getLength()
      var curveLengths = this.getCurveLengths()
      var i = 0 // To think about boundaries points.

      while (i < curveLengths.length) {
        if (curveLengths[i] >= d) {
          var diff = curveLengths[i] - d
          var curve = this.curves[i]
          var segmentLength = curve.getLength()
          var u = segmentLength === 0 ? 0 : 1 - diff / segmentLength
          return curve.getPointAt(u)
        }

        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: function getLength() {
      var lens = this.getCurveLengths()
      return lens[lens.length - 1]
    },
    // cacheLengths must be recalculated.
    updateArcLengths: function updateArcLengths() {
      this.needsUpdate = true
      this.cacheLengths = null
      this.getCurveLengths()
    },
    // Compute lengths and cache them
    // We cannot overwrite getLengths() because UtoT mapping uses it.
    getCurveLengths: function 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

      var lengths = []
      var sums = 0

      for (var i = 0, l = this.curves.length; i < l; i++) {
        sums += this.curves[i].getLength()
        lengths.push(sums)
      }

      this.cacheLengths = lengths
      return lengths
    },
    getSpacedPoints: function getSpacedPoints(divisions) {
      if (divisions === void 0) {
        divisions = 40
      }

      var points = []

      for (var i = 0; i <= divisions; i++) {
        points.push(this.getPoint(i / divisions))
      }

      if (this.autoClose) {
        points.push(points[0])
      }

      return points
    },
    getPoints: function getPoints(divisions) {
      if (divisions === void 0) {
        divisions = 12
      }

      var points = []
      var last

      for (var i = 0, curves = this.curves; i < curves.length; i++) {
        var curve = curves[i]
        var resolution =
          curve && curve.isEllipseCurve
            ? divisions * 2
            : curve && (curve.isLineCurve || curve.isLineCurve3)
            ? 1
            : curve && curve.isSplineCurve
            ? divisions * curve.points.length
            : divisions
        var pts = curve.getPoints(resolution)

        for (var j = 0; j < pts.length; j++) {
          var 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: function copy(source) {
      Curve.prototype.copy.call(this, source)
      this.curves = []

      for (var i = 0, l = source.curves.length; i < l; i++) {
        var curve = source.curves[i]
        this.curves.push(curve.clone())
      }

      this.autoClose = source.autoClose
      return this
    },
    toJSON: function toJSON() {
      var data = Curve.prototype.toJSON.call(this)
      data.autoClose = this.autoClose
      data.curves = []

      for (var i = 0, l = this.curves.length; i < l; i++) {
        var curve = this.curves[i]
        data.curves.push(curve.toJSON())
      }

      return data
    },
    fromJSON: function fromJSON(json) {
      Curve.prototype.fromJSON.call(this, json)
      this.autoClose = json.autoClose
      this.curves = []

      for (var i = 0, l = json.curves.length; i < l; i++) {
        var curve = json.curves[i]
        this.curves.push(new Curves[curve.type]().fromJSON(curve))
      }

      return this
    }
  })

  function Path(points) {
    CurvePath.call(this)
    this.type = 'Path'
    this.currentPoint = new Vector2()

    if (points) {
      this.setFromPoints(points)
    }
  }

  Path.prototype = Object.assign(Object.create(CurvePath.prototype), {
    constructor: Path,
    setFromPoints: function setFromPoints(points) {
      this.moveTo(points[0].x, points[0].y)

      for (var i = 1, l = points.length; i < l; i++) {
        this.lineTo(points[i].x, points[i].y)
      }

      return this
    },
    moveTo: function moveTo(x, y) {
      this.currentPoint.set(x, y) // TODO consider referencing vectors instead of copying?

      return this
    },
    lineTo: function lineTo(x, y) {
      var curve = new LineCurve(this.currentPoint.clone(), new Vector2(x, y))
      this.curves.push(curve)
      this.currentPoint.set(x, y)
      return this
    },
    quadraticCurveTo: function quadraticCurveTo(aCPx, aCPy, aX, aY) {
      var curve = new QuadraticBezierCurve(this.currentPoint.clone(), new Vector2(aCPx, aCPy), new Vector2(aX, aY))
      this.curves.push(curve)
      this.currentPoint.set(aX, aY)
      return this
    },
    bezierCurveTo: function bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
      var curve = new CubicBezierCurve(this.currentPoint.clone(), new Vector2(aCP1x, aCP1y), new Vector2(aCP2x, aCP2y), new Vector2(aX, aY))
      this.curves.push(curve)
      this.currentPoint.set(aX, aY)
      return this
    },
    splineThru: function splineThru(
      pts
      /*Array of Vector*/
    ) {
      var npts = [this.currentPoint.clone()].concat(pts)
      var curve = new SplineCurve(npts)
      this.curves.push(curve)
      this.currentPoint.copy(pts[pts.length - 1])
      return this
    },
    arc: function arc(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
      var x0 = this.currentPoint.x
      var y0 = this.currentPoint.y
      this.absarc(aX + x0, aY + y0, aRadius, aStartAngle, aEndAngle, aClockwise)
      return this
    },
    absarc: function absarc(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
      this.absellipse(aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise)
      return this
    },
    ellipse: function ellipse(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
      var x0 = this.currentPoint.x
      var y0 = this.currentPoint.y
      this.absellipse(aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation)
      return this
    },
    absellipse: function absellipse(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation) {
      var curve = new EllipseCurve(aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation)

      if (this.curves.length > 0) {
        // if a previous curve is present, attempt to join
        var firstPoint = curve.getPoint(0)

        if (!firstPoint.equals(this.currentPoint)) {
          this.lineTo(firstPoint.x, firstPoint.y)
        }
      }

      this.curves.push(curve)
      var lastPoint = curve.getPoint(1)
      this.currentPoint.copy(lastPoint)
      return this
    },
    copy: function copy(source) {
      CurvePath.prototype.copy.call(this, source)
      this.currentPoint.copy(source.currentPoint)
      return this
    },
    toJSON: function toJSON() {
      var data = CurvePath.prototype.toJSON.call(this)
      data.currentPoint = this.currentPoint.toArray()
      return data
    },
    fromJSON: function fromJSON(json) {
      CurvePath.prototype.fromJSON.call(this, json)
      this.currentPoint.fromArray(json.currentPoint)
      return this
    }
  })

  function Shape(points) {
    Path.call(this, points)
    this.uuid = MathUtils.generateUUID()
    this.type = 'Shape'
    this.holes = []
  }

  Shape.prototype = Object.assign(Object.create(Path.prototype), {
    constructor: Shape,
    getPointsHoles: function getPointsHoles(divisions) {
      var holesPts = []

      for (var 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: function extractPoints(divisions) {
      return {
        shape: this.getPoints(divisions),
        holes: this.getPointsHoles(divisions)
      }
    },
    copy: function copy(source) {
      Path.prototype.copy.call(this, source)
      this.holes = []

      for (var i = 0, l = source.holes.length; i < l; i++) {
        var hole = source.holes[i]
        this.holes.push(hole.clone())
      }

      return this
    },
    toJSON: function toJSON() {
      var data = Path.prototype.toJSON.call(this)
      data.uuid = this.uuid
      data.holes = []

      for (var i = 0, l = this.holes.length; i < l; i++) {
        var hole = this.holes[i]
        data.holes.push(hole.toJSON())
      }

      return data
    },
    fromJSON: function fromJSON(json) {
      Path.prototype.fromJSON.call(this, json)
      this.uuid = json.uuid
      this.holes = []

      for (var i = 0, l = json.holes.length; i < l; i++) {
        var hole = json.holes[i]
        this.holes.push(new Path().fromJSON(hole))
      }

      return this
    }
  })

  function Light(color, intensity) {
    if (intensity === void 0) {
      intensity = 1
    }

    Object3D.call(this)
    this.type = 'Light'
    this.color = new Color(color)
    this.intensity = intensity
  }

  Light.prototype = Object.assign(Object.create(Object3D.prototype), {
    constructor: Light,
    isLight: true,
    copy: function copy(source) {
      Object3D.prototype.copy.call(this, source)
      this.color.copy(source.color)
      this.intensity = source.intensity
      return this
    },
    toJSON: function toJSON(meta) {
      var data = Object3D.prototype.toJSON.call(this, 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()
      return data
    }
  })

  function HemisphereLight(skyColor, groundColor, intensity) {
    Light.call(this, skyColor, intensity)
    this.type = 'HemisphereLight'
    this.position.copy(Object3D.DefaultUp)
    this.updateMatrix()
    this.groundColor = new Color(groundColor)
  }

  HemisphereLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: HemisphereLight,
    isHemisphereLight: true,
    copy: function copy(source) {
      Light.prototype.copy.call(this, source)
      this.groundColor.copy(source.groundColor)
      return this
    }
  })

  function LightShadow(camera) {
    this.camera = camera
    this.bias = 0
    this.normalBias = 0
    this.radius = 1
    this.mapSize = new Vector2(512, 512)
    this.map = null
    this.mapPass = null
    this.matrix = new Matrix4()
    this.autoUpdate = true
    this.needsUpdate = false
    this._frustum = new Frustum()
    this._frameExtents = new Vector2(1, 1)
    this._viewportCount = 1
    this._viewports = [new Vector4(0, 0, 1, 1)]
  }

  Object.assign(LightShadow.prototype, {
    _projScreenMatrix: new Matrix4(),
    _lightPositionWorld: new Vector3(),
    _lookTarget: new Vector3(),
    getViewportCount: function getViewportCount() {
      return this._viewportCount
    },
    getFrustum: function getFrustum() {
      return this._frustum
    },
    updateMatrices: function updateMatrices(light) {
      var shadowCamera = this.camera,
        shadowMatrix = this.matrix,
        projScreenMatrix = this._projScreenMatrix,
        lookTarget = this._lookTarget,
        lightPositionWorld = this._lightPositionWorld
      lightPositionWorld.setFromMatrixPosition(light.matrixWorld)
      shadowCamera.position.copy(lightPositionWorld)
      lookTarget.setFromMatrixPosition(light.target.matrixWorld)
      shadowCamera.lookAt(lookTarget)
      shadowCamera.updateMatrixWorld()
      projScreenMatrix.multiplyMatrices(shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse)

      this._frustum.setFromProjectionMatrix(projScreenMatrix)

      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(shadowCamera.projectionMatrix)
      shadowMatrix.multiply(shadowCamera.matrixWorldInverse)
    },
    getViewport: function getViewport(viewportIndex) {
      return this._viewports[viewportIndex]
    },
    getFrameExtents: function getFrameExtents() {
      return this._frameExtents
    },
    copy: function copy(source) {
      this.camera = source.camera.clone()
      this.bias = source.bias
      this.radius = source.radius
      this.mapSize.copy(source.mapSize)
      return this
    },
    clone: function clone() {
      return new this.constructor().copy(this)
    },
    toJSON: function toJSON() {
      var object = {}
      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
    }
  })

  function SpotLightShadow() {
    LightShadow.call(this, new PerspectiveCamera(50, 1, 0.5, 500))
    this.focus = 1
  }

  SpotLightShadow.prototype = Object.assign(Object.create(LightShadow.prototype), {
    constructor: SpotLightShadow,
    isSpotLightShadow: true,
    updateMatrices: function updateMatrices(light) {
      var camera = this.camera
      var fov = MathUtils.RAD2DEG * 2 * light.angle * this.focus
      var aspect = this.mapSize.width / this.mapSize.height
      var 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()
      }

      LightShadow.prototype.updateMatrices.call(this, light)
    }
  })

  function SpotLight(color, intensity, distance, angle, penumbra, decay) {
    Light.call(this, color, intensity)
    this.type = 'SpotLight'
    this.position.copy(Object3D.DefaultUp)
    this.updateMatrix()
    this.target = new Object3D()
    Object.defineProperty(this, 'power', {
      get: function get() {
        // intensity = power per solid angle.
        // ref: equation (17) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        return this.intensity * Math.PI
      },
      set: function set(power) {
        // intensity = power per solid angle.
        // ref: equation (17) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        this.intensity = power / Math.PI
      }
    })
    this.distance = distance !== undefined ? distance : 0
    this.angle = angle !== undefined ? angle : Math.PI / 3
    this.penumbra = penumbra !== undefined ? penumbra : 0
    this.decay = decay !== undefined ? decay : 1 // for physically correct lights, should be 2.

    this.shadow = new SpotLightShadow()
  }

  SpotLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: SpotLight,
    isSpotLight: true,
    copy: function copy(source) {
      Light.prototype.copy.call(this, source)
      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
    }
  })

  function PointLightShadow() {
    LightShadow.call(this, new PerspectiveCamera(90, 1, 0.5, 500))
    this._frameExtents = new Vector2(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 Vector4(2, 1, 1, 1), // negative X
      new Vector4(0, 1, 1, 1), // positive Z
      new Vector4(3, 1, 1, 1), // negative Z
      new Vector4(1, 1, 1, 1), // positive Y
      new Vector4(3, 0, 1, 1), // negative Y
      new Vector4(1, 0, 1, 1)
    ]
    this._cubeDirections = [new Vector3(1, 0, 0), new Vector3(-1, 0, 0), new Vector3(0, 0, 1), new Vector3(0, 0, -1), new Vector3(0, 1, 0), new Vector3(0, -1, 0)]
    this._cubeUps = [new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 1, 0), new Vector3(0, 0, 1), new Vector3(0, 0, -1)]
  }

  PointLightShadow.prototype = Object.assign(Object.create(LightShadow.prototype), {
    constructor: PointLightShadow,
    isPointLightShadow: true,
    updateMatrices: function updateMatrices(light, viewportIndex) {
      if (viewportIndex === void 0) {
        viewportIndex = 0
      }

      var camera = this.camera,
        shadowMatrix = this.matrix,
        lightPositionWorld = this._lightPositionWorld,
        lookTarget = this._lookTarget,
        projScreenMatrix = this._projScreenMatrix
      lightPositionWorld.setFromMatrixPosition(light.matrixWorld)
      camera.position.copy(lightPositionWorld)
      lookTarget.copy(camera.position)
      lookTarget.add(this._cubeDirections[viewportIndex])
      camera.up.copy(this._cubeUps[viewportIndex])
      camera.lookAt(lookTarget)
      camera.updateMatrixWorld()
      shadowMatrix.makeTranslation(-lightPositionWorld.x, -lightPositionWorld.y, -lightPositionWorld.z)
      projScreenMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)

      this._frustum.setFromProjectionMatrix(projScreenMatrix)
    }
  })

  function PointLight(color, intensity, distance, decay) {
    Light.call(this, color, intensity)
    this.type = 'PointLight'
    Object.defineProperty(this, 'power', {
      get: function get() {
        // intensity = power per solid angle.
        // ref: equation (15) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        return this.intensity * 4 * Math.PI
      },
      set: function set(power) {
        // intensity = power per solid angle.
        // ref: equation (15) from https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
        this.intensity = power / (4 * Math.PI)
      }
    })
    this.distance = distance !== undefined ? distance : 0
    this.decay = decay !== undefined ? decay : 1 // for physically correct lights, should be 2.

    this.shadow = new PointLightShadow()
  }

  PointLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: PointLight,
    isPointLight: true,
    copy: function copy(source) {
      Light.prototype.copy.call(this, source)
      this.distance = source.distance
      this.decay = source.decay
      this.shadow = source.shadow.clone()
      return this
    }
  })

  function OrthographicCamera(left, right, top, bottom, near, far) {
    Camera.call(this)
    this.type = 'OrthographicCamera'
    this.zoom = 1
    this.view = null
    this.left = left !== undefined ? left : -1
    this.right = right !== undefined ? right : 1
    this.top = top !== undefined ? top : 1
    this.bottom = bottom !== undefined ? bottom : -1
    this.near = near !== undefined ? near : 0.1
    this.far = far !== undefined ? far : 2000
    this.updateProjectionMatrix()
  }

  OrthographicCamera.prototype = Object.assign(Object.create(Camera.prototype), {
    constructor: OrthographicCamera,
    isOrthographicCamera: true,
    copy: function copy(source, recursive) {
      Camera.prototype.copy.call(this, 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: function 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: function clearViewOffset() {
      if (this.view !== null) {
        this.view.enabled = false
      }

      this.updateProjectionMatrix()
    },
    updateProjectionMatrix: function updateProjectionMatrix() {
      var dx = (this.right - this.left) / (2 * this.zoom)
      var dy = (this.top - this.bottom) / (2 * this.zoom)
      var cx = (this.right + this.left) / 2
      var cy = (this.top + this.bottom) / 2
      var left = cx - dx
      var right = cx + dx
      var top = cy + dy
      var bottom = cy - dy

      if (this.view !== null && this.view.enabled) {
        var scaleW = (this.right - this.left) / this.view.fullWidth / this.zoom
        var 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.projectionMatrixInverse.copy(this.projectionMatrix).invert()
    },
    toJSON: function toJSON(meta) {
      var data = Object3D.prototype.toJSON.call(this, 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
    }
  })

  function DirectionalLightShadow() {
    LightShadow.call(this, new OrthographicCamera(-5, 5, 5, -5, 0.5, 500))
  }

  DirectionalLightShadow.prototype = Object.assign(Object.create(LightShadow.prototype), {
    constructor: DirectionalLightShadow,
    isDirectionalLightShadow: true,
    updateMatrices: function updateMatrices(light) {
      LightShadow.prototype.updateMatrices.call(this, light)
    }
  })

  function DirectionalLight(color, intensity) {
    Light.call(this, color, intensity)
    this.type = 'DirectionalLight'
    this.position.copy(Object3D.DefaultUp)
    this.updateMatrix()
    this.target = new Object3D()
    this.shadow = new DirectionalLightShadow()
  }

  DirectionalLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: DirectionalLight,
    isDirectionalLight: true,
    copy: function copy(source) {
      Light.prototype.copy.call(this, source)
      this.target = source.target.clone()
      this.shadow = source.shadow.clone()
      return this
    }
  })

  function AmbientLight(color, intensity) {
    Light.call(this, color, intensity)
    this.type = 'AmbientLight'
  }

  AmbientLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: AmbientLight,
    isAmbientLight: true
  })

  function RectAreaLight(color, intensity, width, height) {
    Light.call(this, color, intensity)
    this.type = 'RectAreaLight'
    this.width = width !== undefined ? width : 10
    this.height = height !== undefined ? height : 10
  }

  RectAreaLight.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: RectAreaLight,
    isRectAreaLight: true,
    copy: function copy(source) {
      Light.prototype.copy.call(this, source)
      this.width = source.width
      this.height = source.height
      return this
    },
    toJSON: function toJSON(meta) {
      var data = Light.prototype.toJSON.call(this, 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

  var SphericalHarmonics3 = /*#__PURE__*/ (function () {
    function SphericalHarmonics3() {
      Object.defineProperty(this, 'isSphericalHarmonics3', {
        value: true
      })
      this.coefficients = []

      for (var i = 0; i < 9; i++) {
        this.coefficients.push(new Vector3())
      }
    }

    var _proto = SphericalHarmonics3.prototype

    _proto.set = function set(coefficients) {
      for (var i = 0; i < 9; i++) {
        this.coefficients[i].copy(coefficients[i])
      }

      return this
    }

    _proto.zero = function zero() {
      for (var 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

    _proto.getAt = function getAt(normal, target) {
      // normal is assumed to be unit length
      var x = normal.x,
        y = normal.y,
        z = normal.z
      var 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

    _proto.getIrradianceAt = function getIrradianceAt(normal, target) {
      // normal is assumed to be unit length
      var x = normal.x,
        y = normal.y,
        z = normal.z
      var coeff = this.coefficients // band 0

      target.copy(coeff[0]).multiplyScalar(0.886227) // π * 0.282095
      // band 1

      target.addScaledVector(coeff[1], 2.0 * 0.511664 * y) // ( 2 * π / 3 ) * 0.488603

      target.addScaledVector(coeff[2], 2.0 * 0.511664 * z)
      target.addScaledVector(coeff[3], 2.0 * 0.511664 * x) // band 2

      target.addScaledVector(coeff[4], 2.0 * 0.429043 * x * y) // ( π / 4 ) * 1.092548

      target.addScaledVector(coeff[5], 2.0 * 0.429043 * y * z)
      target.addScaledVector(coeff[6], 0.743125 * z * z - 0.247708) // ( π / 4 ) * 0.315392 * 3

      target.addScaledVector(coeff[7], 2.0 * 0.429043 * x * z)
      target.addScaledVector(coeff[8], 0.429043 * (x * x - y * y)) // ( π / 4 ) * 0.546274

      return target
    }

    _proto.add = function add(sh) {
      for (var i = 0; i < 9; i++) {
        this.coefficients[i].add(sh.coefficients[i])
      }

      return this
    }

    _proto.addScaledSH = function addScaledSH(sh, s) {
      for (var i = 0; i < 9; i++) {
        this.coefficients[i].addScaledVector(sh.coefficients[i], s)
      }

      return this
    }

    _proto.scale = function scale(s) {
      for (var i = 0; i < 9; i++) {
        this.coefficients[i].multiplyScalar(s)
      }

      return this
    }

    _proto.lerp = function lerp(sh, alpha) {
      for (var i = 0; i < 9; i++) {
        this.coefficients[i].lerp(sh.coefficients[i], alpha)
      }

      return this
    }

    _proto.equals = function equals(sh) {
      for (var i = 0; i < 9; i++) {
        if (!this.coefficients[i].equals(sh.coefficients[i])) {
          return false
        }
      }

      return true
    }

    _proto.copy = function copy(sh) {
      return this.set(sh.coefficients)
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.fromArray = function fromArray(array, offset) {
      if (offset === void 0) {
        offset = 0
      }

      var coefficients = this.coefficients

      for (var i = 0; i < 9; i++) {
        coefficients[i].fromArray(array, offset + i * 3)
      }

      return this
    }

    _proto.toArray = function toArray(array, offset) {
      if (array === void 0) {
        array = []
      }

      if (offset === void 0) {
        offset = 0
      }

      var coefficients = this.coefficients

      for (var i = 0; i < 9; i++) {
        coefficients[i].toArray(array, offset + i * 3)
      }

      return array
    } // evaluate the basis functions
    // shBasis is an Array[ 9 ]

    SphericalHarmonics3.getBasisAt = function getBasisAt(normal, shBasis) {
      // normal is assumed to be unit length
      var 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)
    }

    return SphericalHarmonics3
  })()

  function LightProbe(sh, intensity) {
    Light.call(this, undefined, intensity)
    this.type = 'LightProbe'
    this.sh = sh !== undefined ? sh : new SphericalHarmonics3()
  }

  LightProbe.prototype = Object.assign(Object.create(Light.prototype), {
    constructor: LightProbe,
    isLightProbe: true,
    copy: function copy(source) {
      Light.prototype.copy.call(this, source)
      this.sh.copy(source.sh)
      return this
    },
    fromJSON: function fromJSON(json) {
      this.intensity = json.intensity // TODO: Move this bit to Light.fromJSON();

      this.sh.fromArray(json.sh)
      return this
    },
    toJSON: function toJSON(meta) {
      var data = Light.prototype.toJSON.call(this, meta)
      data.object.sh = this.sh.toArray()
      return data
    }
  })

  function MaterialLoader(manager) {
    Loader.call(this, manager)
    this.textures = {}
  }

  MaterialLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: MaterialLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var loader = new FileLoader(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: function parse(json) {
      var textures = this.textures

      function getTexture(name) {
        if (textures[name] === undefined) {
          console.warn('THREE.MaterialLoader: Undefined texture', name)
        }

        return textures[name]
      }

      var material = new Materials[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 = new Color().setHex(json.sheen)
      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.shininess !== undefined) material.shininess = json.shininess
      if (json.clearcoat !== undefined) material.clearcoat = json.clearcoat
      if (json.clearcoatRoughness !== undefined) material.clearcoatRoughness = json.clearcoatRoughness
      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.opacity !== undefined) material.opacity = json.opacity
      if (json.transparent !== undefined) material.transparent = json.transparent
      if (json.alphaTest !== undefined) material.alphaTest = json.alphaTest
      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.stencilWrite !== undefined) material.stencilWrite = json.stencilWrite
      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.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 !== 1) 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.skinning !== undefined) material.skinning = json.skinning
      if (json.morphTargets !== undefined) material.morphTargets = json.morphTargets
      if (json.morphNormals !== undefined) material.morphNormals = json.morphNormals
      if (json.dithering !== undefined) material.dithering = json.dithering
      if (json.vertexTangents !== undefined) material.vertexTangents = json.vertexTangents
      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 (var name in json.uniforms) {
          var 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 Color().setHex(uniform.value)
              break

            case 'v2':
              material.uniforms[name].value = new Vector2().fromArray(uniform.value)
              break

            case 'v3':
              material.uniforms[name].value = new Vector3().fromArray(uniform.value)
              break

            case 'v4':
              material.uniforms[name].value = new Vector4().fromArray(uniform.value)
              break

            case 'm3':
              material.uniforms[name].value = new Matrix3().fromArray(uniform.value)
              break

            case 'm4':
              material.uniforms[name].value = new Matrix4().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.extensions !== undefined) {
        for (var key in json.extensions) {
          material.extensions[key] = json.extensions[key]
        }
      } // Deprecated

      if (json.shading !== undefined) material.flatShading = json.shading === 1 // THREE.FlatShading
      // 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) {
        var normalScale = json.normalScale

        if (Array.isArray(normalScale) === false) {
          // Blender exporter used to export a scalar. See #7459
          normalScale = [normalScale, normalScale]
        }

        material.normalScale = new Vector2().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.envMap !== undefined) material.envMap = getTexture(json.envMap)
      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 Vector2().fromArray(json.clearcoatNormalScale)
      if (json.transmission !== undefined) material.transmission = json.transmission
      if (json.transmissionMap !== undefined) material.transmissionMap = getTexture(json.transmissionMap)
      return material
    },
    setTextures: function setTextures(value) {
      this.textures = value
      return this
    }
  })

  var LoaderUtils = {
    decodeText: function decodeText(array) {
      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.

      var s = ''

      for (var 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) {
        // see #16358
        return s
      }
    },
    extractUrlBase: function extractUrlBase(url) {
      var index = url.lastIndexOf('/')
      if (index === -1) return './'
      return url.substr(0, index + 1)
    }
  }

  function InstancedBufferGeometry() {
    BufferGeometry.call(this)
    this.type = 'InstancedBufferGeometry'
    this.instanceCount = Infinity
  }

  InstancedBufferGeometry.prototype = Object.assign(Object.create(BufferGeometry.prototype), {
    constructor: InstancedBufferGeometry,
    isInstancedBufferGeometry: true,
    copy: function copy(source) {
      BufferGeometry.prototype.copy.call(this, source)
      this.instanceCount = source.instanceCount
      return this
    },
    clone: function clone() {
      return new this.constructor().copy(this)
    },
    toJSON: function toJSON() {
      var data = BufferGeometry.prototype.toJSON.call(this)
      data.instanceCount = this.instanceCount
      data.isInstancedBufferGeometry = true
      return data
    }
  })

  function InstancedBufferAttribute(array, itemSize, normalized, meshPerAttribute) {
    if (typeof normalized === 'number') {
      meshPerAttribute = normalized
      normalized = false
      console.error('THREE.InstancedBufferAttribute: The constructor now expects normalized as the third argument.')
    }

    BufferAttribute.call(this, array, itemSize, normalized)
    this.meshPerAttribute = meshPerAttribute || 1
  }

  InstancedBufferAttribute.prototype = Object.assign(Object.create(BufferAttribute.prototype), {
    constructor: InstancedBufferAttribute,
    isInstancedBufferAttribute: true,
    copy: function copy(source) {
      BufferAttribute.prototype.copy.call(this, source)
      this.meshPerAttribute = source.meshPerAttribute
      return this
    },
    toJSON: function toJSON() {
      var data = BufferAttribute.prototype.toJSON.call(this)
      data.meshPerAttribute = this.meshPerAttribute
      data.isInstancedBufferAttribute = true
      return data
    }
  })

  function BufferGeometryLoader(manager) {
    Loader.call(this, manager)
  }

  BufferGeometryLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: BufferGeometryLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var loader = new FileLoader(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: function parse(json) {
      var interleavedBufferMap = {}
      var arrayBufferMap = {}

      function getInterleavedBuffer(json, uuid) {
        if (interleavedBufferMap[uuid] !== undefined) return interleavedBufferMap[uuid]
        var interleavedBuffers = json.interleavedBuffers
        var interleavedBuffer = interleavedBuffers[uuid]
        var buffer = getArrayBuffer(json, interleavedBuffer.buffer)
        var array = getTypedArray(interleavedBuffer.type, buffer)
        var ib = new InterleavedBuffer(array, interleavedBuffer.stride)
        ib.uuid = interleavedBuffer.uuid
        interleavedBufferMap[uuid] = ib
        return ib
      }

      function getArrayBuffer(json, uuid) {
        if (arrayBufferMap[uuid] !== undefined) return arrayBufferMap[uuid]
        var arrayBuffers = json.arrayBuffers
        var arrayBuffer = arrayBuffers[uuid]
        var ab = new Uint32Array(arrayBuffer).buffer
        arrayBufferMap[uuid] = ab
        return ab
      }

      var geometry = json.isInstancedBufferGeometry ? new InstancedBufferGeometry() : new BufferGeometry()
      var index = json.data.index

      if (index !== undefined) {
        var typedArray = getTypedArray(index.type, index.array)
        geometry.setIndex(new BufferAttribute(typedArray, 1))
      }

      var attributes = json.data.attributes

      for (var key in attributes) {
        var attribute = attributes[key]
        var bufferAttribute = void 0

        if (attribute.isInterleavedBufferAttribute) {
          var interleavedBuffer = getInterleavedBuffer(json.data, attribute.data)
          bufferAttribute = new InterleavedBufferAttribute(interleavedBuffer, attribute.itemSize, attribute.offset, attribute.normalized)
        } else {
          var _typedArray = getTypedArray(attribute.type, attribute.array)

          var bufferAttributeConstr = attribute.isInstancedBufferAttribute ? InstancedBufferAttribute : BufferAttribute
          bufferAttribute = new bufferAttributeConstr(_typedArray, attribute.itemSize, attribute.normalized)
        }

        if (attribute.name !== undefined) bufferAttribute.name = attribute.name
        geometry.setAttribute(key, bufferAttribute)
      }

      var morphAttributes = json.data.morphAttributes

      if (morphAttributes) {
        for (var _key in morphAttributes) {
          var attributeArray = morphAttributes[_key]
          var array = []

          for (var i = 0, il = attributeArray.length; i < il; i++) {
            var _attribute = attributeArray[i]

            var _bufferAttribute = void 0

            if (_attribute.isInterleavedBufferAttribute) {
              var _interleavedBuffer = getInterleavedBuffer(json.data, _attribute.data)

              _bufferAttribute = new InterleavedBufferAttribute(_interleavedBuffer, _attribute.itemSize, _attribute.offset, _attribute.normalized)
            } else {
              var _typedArray2 = getTypedArray(_attribute.type, _attribute.array)

              _bufferAttribute = new BufferAttribute(_typedArray2, _attribute.itemSize, _attribute.normalized)
            }

            if (_attribute.name !== undefined) _bufferAttribute.name = _attribute.name
            array.push(_bufferAttribute)
          }

          geometry.morphAttributes[_key] = array
        }
      }

      var morphTargetsRelative = json.data.morphTargetsRelative

      if (morphTargetsRelative) {
        geometry.morphTargetsRelative = true
      }

      var groups = json.data.groups || json.data.drawcalls || json.data.offsets

      if (groups !== undefined) {
        for (var _i = 0, n = groups.length; _i !== n; ++_i) {
          var group = groups[_i]
          geometry.addGroup(group.start, group.count, group.materialIndex)
        }
      }

      var boundingSphere = json.data.boundingSphere

      if (boundingSphere !== undefined) {
        var center = new Vector3()

        if (boundingSphere.center !== undefined) {
          center.fromArray(boundingSphere.center)
        }

        geometry.boundingSphere = new Sphere(center, boundingSphere.radius)
      }

      if (json.name) geometry.name = json.name
      if (json.userData) geometry.userData = json.userData
      return geometry
    }
  })

  var ObjectLoader = /*#__PURE__*/ (function (_Loader) {
    _inheritsLoose(ObjectLoader, _Loader)

    function ObjectLoader(manager) {
      return _Loader.call(this, manager) || this
    }

    var _proto = ObjectLoader.prototype

    _proto.load = function load(url, onLoad, onProgress, onError) {
      var scope = this
      var path = this.path === '' ? LoaderUtils.extractUrlBase(url) : this.path
      this.resourcePath = this.resourcePath || path
      var loader = new FileLoader(this.manager)
      loader.setPath(this.path)
      loader.setRequestHeader(this.requestHeader)
      loader.setWithCredentials(this.withCredentials)
      loader.load(
        url,
        function (text) {
          var 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
          }

          var metadata = json.metadata

          if (metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry') {
            console.error("THREE.ObjectLoader: Can't load " + url)
            return
          }

          scope.parse(json, onLoad)
        },
        onProgress,
        onError
      )
    }

    _proto.parse = function parse(json, onLoad) {
      var animations = this.parseAnimations(json.animations)
      var shapes = this.parseShapes(json.shapes)
      var geometries = this.parseGeometries(json.geometries, shapes)
      var images = this.parseImages(json.images, function () {
        if (onLoad !== undefined) onLoad(object)
      })
      var textures = this.parseTextures(json.textures, images)
      var materials = this.parseMaterials(json.materials, textures)
      var object = this.parseObject(json.object, geometries, materials, animations)
      var skeletons = this.parseSkeletons(json.skeletons, object)
      this.bindSkeletons(object, skeletons) //

      if (onLoad !== undefined) {
        var hasImages = false

        for (var uuid in images) {
          if (images[uuid] instanceof HTMLImageElement) {
            hasImages = true
            break
          }
        }

        if (hasImages === false) onLoad(object)
      }

      return object
    }

    _proto.parseShapes = function parseShapes(json) {
      var shapes = {}

      if (json !== undefined) {
        for (var i = 0, l = json.length; i < l; i++) {
          var shape = new Shape().fromJSON(json[i])
          shapes[shape.uuid] = shape
        }
      }

      return shapes
    }

    _proto.parseSkeletons = function parseSkeletons(json, object) {
      var skeletons = {}
      var bones = {} // generate bone lookup table

      object.traverse(function (child) {
        if (child.isBone) bones[child.uuid] = child
      }) // create skeletons

      if (json !== undefined) {
        for (var i = 0, l = json.length; i < l; i++) {
          var skeleton = new Skeleton().fromJSON(json[i], bones)
          skeletons[skeleton.uuid] = skeleton
        }
      }

      return skeletons
    }

    _proto.parseGeometries = function parseGeometries(json, shapes) {
      var geometries = {}
      var geometryShapes

      if (json !== undefined) {
        var bufferGeometryLoader = new BufferGeometryLoader()

        for (var i = 0, l = json.length; i < l; i++) {
          var geometry = void 0
          var data = json[i]

          switch (data.type) {
            case 'PlaneGeometry':
            case 'PlaneBufferGeometry':
              geometry = new Geometries[data.type](data.width, data.height, data.widthSegments, data.heightSegments)
              break

            case 'BoxGeometry':
            case 'BoxBufferGeometry':
            case 'CubeGeometry':
              // backwards compatible
              geometry = new Geometries[data.type](data.width, data.height, data.depth, data.widthSegments, data.heightSegments, data.depthSegments)
              break

            case 'CircleGeometry':
            case 'CircleBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.segments, data.thetaStart, data.thetaLength)
              break

            case 'CylinderGeometry':
            case 'CylinderBufferGeometry':
              geometry = new Geometries[data.type](
                data.radiusTop,
                data.radiusBottom,
                data.height,
                data.radialSegments,
                data.heightSegments,
                data.openEnded,
                data.thetaStart,
                data.thetaLength
              )
              break

            case 'ConeGeometry':
            case 'ConeBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.height, data.radialSegments, data.heightSegments, data.openEnded, data.thetaStart, data.thetaLength)
              break

            case 'SphereGeometry':
            case 'SphereBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.widthSegments, data.heightSegments, data.phiStart, data.phiLength, data.thetaStart, data.thetaLength)
              break

            case 'DodecahedronGeometry':
            case 'DodecahedronBufferGeometry':
            case 'IcosahedronGeometry':
            case 'IcosahedronBufferGeometry':
            case 'OctahedronGeometry':
            case 'OctahedronBufferGeometry':
            case 'TetrahedronGeometry':
            case 'TetrahedronBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.detail)
              break

            case 'RingGeometry':
            case 'RingBufferGeometry':
              geometry = new Geometries[data.type](data.innerRadius, data.outerRadius, data.thetaSegments, data.phiSegments, data.thetaStart, data.thetaLength)
              break

            case 'TorusGeometry':
            case 'TorusBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.tube, data.radialSegments, data.tubularSegments, data.arc)
              break

            case 'TorusKnotGeometry':
            case 'TorusKnotBufferGeometry':
              geometry = new Geometries[data.type](data.radius, data.tube, data.tubularSegments, data.radialSegments, data.p, data.q)
              break

            case 'TubeGeometry':
            case 'TubeBufferGeometry':
              // This only works for built-in curves (e.g. CatmullRomCurve3).
              // User defined curves or instances of CurvePath will not be deserialized.
              geometry = new Geometries[data.type](new Curves[data.path.type]().fromJSON(data.path), data.tubularSegments, data.radius, data.radialSegments, data.closed)
              break

            case 'LatheGeometry':
            case 'LatheBufferGeometry':
              geometry = new Geometries[data.type](data.points, data.segments, data.phiStart, data.phiLength)
              break

            case 'PolyhedronGeometry':
            case 'PolyhedronBufferGeometry':
              geometry = new Geometries[data.type](data.vertices, data.indices, data.radius, data.details)
              break

            case 'ShapeGeometry':
            case 'ShapeBufferGeometry':
              geometryShapes = []

              for (var j = 0, jl = data.shapes.length; j < jl; j++) {
                var shape = shapes[data.shapes[j]]
                geometryShapes.push(shape)
              }

              geometry = new Geometries[data.type](geometryShapes, data.curveSegments)
              break

            case 'ExtrudeGeometry':
            case 'ExtrudeBufferGeometry':
              geometryShapes = []

              for (var _j = 0, _jl = data.shapes.length; _j < _jl; _j++) {
                var _shape = shapes[data.shapes[_j]]
                geometryShapes.push(_shape)
              }

              var extrudePath = data.options.extrudePath

              if (extrudePath !== undefined) {
                data.options.extrudePath = new Curves[extrudePath.type]().fromJSON(extrudePath)
              }

              geometry = new Geometries[data.type](geometryShapes, data.options)
              break

            case 'BufferGeometry':
            case 'InstancedBufferGeometry':
              geometry = bufferGeometryLoader.parse(data)
              break

            case 'Geometry':
              console.error('THREE.ObjectLoader: Loading "Geometry" is not supported anymore.')
              break

            default:
              console.warn('THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"')
              continue
          }

          geometry.uuid = data.uuid
          if (data.name !== undefined) geometry.name = data.name
          if (geometry.isBufferGeometry === true && data.userData !== undefined) geometry.userData = data.userData
          geometries[data.uuid] = geometry
        }
      }

      return geometries
    }

    _proto.parseMaterials = function parseMaterials(json, textures) {
      var cache = {} // MultiMaterial

      var materials = {}

      if (json !== undefined) {
        var loader = new MaterialLoader()
        loader.setTextures(textures)

        for (var i = 0, l = json.length; i < l; i++) {
          var data = json[i]

          if (data.type === 'MultiMaterial') {
            // Deprecated
            var array = []

            for (var j = 0; j < data.materials.length; j++) {
              var material = data.materials[j]

              if (cache[material.uuid] === undefined) {
                cache[material.uuid] = loader.parse(material)
              }

              array.push(cache[material.uuid])
            }

            materials[data.uuid] = array
          } else {
            if (cache[data.uuid] === undefined) {
              cache[data.uuid] = loader.parse(data)
            }

            materials[data.uuid] = cache[data.uuid]
          }
        }
      }

      return materials
    }

    _proto.parseAnimations = function parseAnimations(json) {
      var animations = {}

      if (json !== undefined) {
        for (var i = 0; i < json.length; i++) {
          var data = json[i]
          var clip = AnimationClip.parse(data)
          animations[clip.uuid] = clip
        }
      }

      return animations
    }

    _proto.parseImages = function parseImages(json, onLoad) {
      var scope = this
      var images = {}
      var 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') {
          var url = image
          var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test(url) ? url : scope.resourcePath + url
          return loadImage(path)
        } else {
          if (image.data) {
            return {
              data: getTypedArray(image.type, image.data),
              width: image.width,
              height: image.height
            }
          } else {
            return null
          }
        }
      }

      if (json !== undefined && json.length > 0) {
        var manager = new LoadingManager(onLoad)
        loader = new ImageLoader(manager)
        loader.setCrossOrigin(this.crossOrigin)

        for (var i = 0, il = json.length; i < il; i++) {
          var image = json[i]
          var url = image.url

          if (Array.isArray(url)) {
            // load array of images e.g CubeTexture
            images[image.uuid] = []

            for (var j = 0, jl = url.length; j < jl; j++) {
              var currentUrl = url[j]
              var deserializedImage = deserializeImage(currentUrl)

              if (deserializedImage !== null) {
                if (deserializedImage instanceof HTMLImageElement) {
                  images[image.uuid].push(deserializedImage)
                } else {
                  // special case: handle array of data textures for cube textures
                  images[image.uuid].push(new DataTexture(deserializedImage.data, deserializedImage.width, deserializedImage.height))
                }
              }
            }
          } else {
            // load single image
            var _deserializedImage = deserializeImage(image.url)

            if (_deserializedImage !== null) {
              images[image.uuid] = _deserializedImage
            }
          }
        }
      }

      return images
    }

    _proto.parseTextures = function 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]
      }

      var textures = {}

      if (json !== undefined) {
        for (var i = 0, l = json.length; i < l; i++) {
          var 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)
          }

          var texture = void 0
          var image = images[data.image]

          if (Array.isArray(image)) {
            texture = new CubeTexture(image)
            if (image.length === 6) texture.needsUpdate = true
          } else {
            if (image && image.data) {
              texture = new DataTexture(image.data, image.width, image.height)
            } else {
              texture = new Texture(image)
            }

            if (image) texture.needsUpdate = true // textures can have undefined image data
          }

          texture.uuid = data.uuid
          if (data.name !== undefined) texture.name = data.name
          if (data.mapping !== undefined) texture.mapping = parseConstant(data.mapping, TEXTURE_MAPPING)
          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], TEXTURE_WRAPPING)
            texture.wrapT = parseConstant(data.wrap[1], TEXTURE_WRAPPING)
          }

          if (data.format !== undefined) texture.format = data.format
          if (data.type !== undefined) texture.type = data.type
          if (data.encoding !== undefined) texture.encoding = data.encoding
          if (data.minFilter !== undefined) texture.minFilter = parseConstant(data.minFilter, TEXTURE_FILTER)
          if (data.magFilter !== undefined) texture.magFilter = parseConstant(data.magFilter, TEXTURE_FILTER)
          if (data.anisotropy !== undefined) texture.anisotropy = data.anisotropy
          if (data.flipY !== undefined) texture.flipY = data.flipY
          if (data.premultiplyAlpha !== undefined) texture.premultiplyAlpha = data.premultiplyAlpha
          if (data.unpackAlignment !== undefined) texture.unpackAlignment = data.unpackAlignment
          textures[data.uuid] = texture
        }
      }

      return textures
    }

    _proto.parseObject = function parseObject(data, geometries, materials, animations) {
      var 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)) {
          var array = []

          for (var i = 0, l = name.length; i < l; i++) {
            var 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]
      }

      var geometry, material

      switch (data.type) {
        case 'Scene':
          object = new Scene()

          if (data.background !== undefined) {
            if (Number.isInteger(data.background)) {
              object.background = new Color(data.background)
            }
          }

          if (data.fog !== undefined) {
            if (data.fog.type === 'Fog') {
              object.fog = new Fog(data.fog.color, data.fog.near, data.fog.far)
            } else if (data.fog.type === 'FogExp2') {
              object.fog = new FogExp2(data.fog.color, data.fog.density)
            }
          }

          break

        case 'PerspectiveCamera':
          object = new PerspectiveCamera(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 OrthographicCamera(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 AmbientLight(data.color, data.intensity)
          break

        case 'DirectionalLight':
          object = new DirectionalLight(data.color, data.intensity)
          break

        case 'PointLight':
          object = new PointLight(data.color, data.intensity, data.distance, data.decay)
          break

        case 'RectAreaLight':
          object = new RectAreaLight(data.color, data.intensity, data.width, data.height)
          break

        case 'SpotLight':
          object = new SpotLight(data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay)
          break

        case 'HemisphereLight':
          object = new HemisphereLight(data.color, data.groundColor, data.intensity)
          break

        case 'LightProbe':
          object = new LightProbe().fromJSON(data)
          break

        case 'SkinnedMesh':
          geometry = getGeometry(data.geometry)
          material = getMaterial(data.material)
          object = new SkinnedMesh(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 Mesh(geometry, material)
          break

        case 'InstancedMesh':
          geometry = getGeometry(data.geometry)
          material = getMaterial(data.material)
          var count = data.count
          var instanceMatrix = data.instanceMatrix
          object = new InstancedMesh(geometry, material, count)
          object.instanceMatrix = new BufferAttribute(new Float32Array(instanceMatrix.array), 16)
          break

        case 'LOD':
          object = new LOD()
          break

        case 'Line':
          object = new Line(getGeometry(data.geometry), getMaterial(data.material), data.mode)
          break

        case 'LineLoop':
          object = new LineLoop(getGeometry(data.geometry), getMaterial(data.material))
          break

        case 'LineSegments':
          object = new LineSegments(getGeometry(data.geometry), getMaterial(data.material))
          break

        case 'PointCloud':
        case 'Points':
          object = new Points(getGeometry(data.geometry), getMaterial(data.material))
          break

        case 'Sprite':
          object = new Sprite(getMaterial(data.material))
          break

        case 'Group':
          object = new Group()
          break

        case 'Bone':
          object = new Bone()
          break

        default:
          object = new Object3D()
      }

      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.castShadow !== undefined) object.castShadow = data.castShadow
      if (data.receiveShadow !== undefined) object.receiveShadow = data.receiveShadow

      if (data.shadow) {
        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) {
        var children = data.children

        for (var i = 0; i < children.length; i++) {
          object.add(this.parseObject(children[i], geometries, materials, animations))
        }
      }

      if (data.animations !== undefined) {
        var objectAnimations = data.animations

        for (var _i = 0; _i < objectAnimations.length; _i++) {
          var uuid = objectAnimations[_i]
          object.animations.push(animations[uuid])
        }
      }

      if (data.type === 'LOD') {
        if (data.autoUpdate !== undefined) object.autoUpdate = data.autoUpdate
        var levels = data.levels

        for (var l = 0; l < levels.length; l++) {
          var level = levels[l]
          var child = object.getObjectByProperty('uuid', level.object)

          if (child !== undefined) {
            object.addLevel(child, level.distance)
          }
        }
      }

      return object
    }

    _proto.bindSkeletons = function bindSkeletons(object, skeletons) {
      if (Object.keys(skeletons).length === 0) return
      object.traverse(function (child) {
        if (child.isSkinnedMesh === true && child.skeleton !== undefined) {
          var skeleton = skeletons[child.skeleton]

          if (skeleton === undefined) {
            console.warn('THREE.ObjectLoader: No skeleton found with UUID:', child.skeleton)
          } else {
            child.bind(skeleton, child.bindMatrix)
          }
        }
      })
    }
    /* DEPRECATED */

    _proto.setTexturePath = function setTexturePath(value) {
      console.warn('THREE.ObjectLoader: .setTexturePath() has been renamed to .setResourcePath().')
      return this.setResourcePath(value)
    }

    return ObjectLoader
  })(Loader)

  var TEXTURE_MAPPING = {
    UVMapping: UVMapping,
    CubeReflectionMapping: CubeReflectionMapping,
    CubeRefractionMapping: CubeRefractionMapping,
    EquirectangularReflectionMapping: EquirectangularReflectionMapping,
    EquirectangularRefractionMapping: EquirectangularRefractionMapping,
    CubeUVReflectionMapping: CubeUVReflectionMapping,
    CubeUVRefractionMapping: CubeUVRefractionMapping
  }
  var TEXTURE_WRAPPING = {
    RepeatWrapping: RepeatWrapping,
    ClampToEdgeWrapping: ClampToEdgeWrapping,
    MirroredRepeatWrapping: MirroredRepeatWrapping
  }
  var TEXTURE_FILTER = {
    NearestFilter: NearestFilter,
    NearestMipmapNearestFilter: NearestMipmapNearestFilter,
    NearestMipmapLinearFilter: NearestMipmapLinearFilter,
    LinearFilter: LinearFilter,
    LinearMipmapNearestFilter: LinearMipmapNearestFilter,
    LinearMipmapLinearFilter: LinearMipmapLinearFilter
  }

  function ImageBitmapLoader(manager) {
    if (typeof createImageBitmap === 'undefined') {
      console.warn('THREE.ImageBitmapLoader: createImageBitmap() not supported.')
    }

    if (typeof fetch === 'undefined') {
      console.warn('THREE.ImageBitmapLoader: fetch() not supported.')
    }

    Loader.call(this, manager)
    this.options = {
      premultiplyAlpha: 'none'
    }
  }

  ImageBitmapLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: ImageBitmapLoader,
    isImageBitmapLoader: true,
    setOptions: function setOptions(options) {
      this.options = options
      return this
    },
    load: function load(url, onLoad, onProgress, onError) {
      if (url === undefined) url = ''
      if (this.path !== undefined) url = this.path + url
      url = this.manager.resolveURL(url)
      var scope = this
      var cached = Cache.get(url)

      if (cached !== undefined) {
        scope.manager.itemStart(url)
        setTimeout(function () {
          if (onLoad) onLoad(cached)
          scope.manager.itemEnd(url)
        }, 0)
        return cached
      }

      var fetchOptions = {}
      fetchOptions.credentials = this.crossOrigin === 'anonymous' ? 'same-origin' : 'include'
      fetch(url, fetchOptions)
        .then(function (res) {
          return res.blob()
        })
        .then(function (blob) {
          return createImageBitmap(blob, scope.options)
        })
        .then(function (imageBitmap) {
          Cache.add(url, imageBitmap)
          if (onLoad) onLoad(imageBitmap)
          scope.manager.itemEnd(url)
        })
        .catch(function (e) {
          if (onError) onError(e)
          scope.manager.itemError(url)
          scope.manager.itemEnd(url)
        })
      scope.manager.itemStart(url)
    }
  })

  function ShapePath() {
    this.type = 'ShapePath'
    this.color = new Color()
    this.subPaths = []
    this.currentPath = null
  }

  Object.assign(ShapePath.prototype, {
    moveTo: function moveTo(x, y) {
      this.currentPath = new Path()
      this.subPaths.push(this.currentPath)
      this.currentPath.moveTo(x, y)
      return this
    },
    lineTo: function lineTo(x, y) {
      this.currentPath.lineTo(x, y)
      return this
    },
    quadraticCurveTo: function quadraticCurveTo(aCPx, aCPy, aX, aY) {
      this.currentPath.quadraticCurveTo(aCPx, aCPy, aX, aY)
      return this
    },
    bezierCurveTo: function bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
      this.currentPath.bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY)
      return this
    },
    splineThru: function splineThru(pts) {
      this.currentPath.splineThru(pts)
      return this
    },
    toShapes: function toShapes(isCCW, noHoles) {
      function toShapesNoHoles(inSubpaths) {
        var shapes = []

        for (var i = 0, l = inSubpaths.length; i < l; i++) {
          var _tmpPath = inSubpaths[i]

          var _tmpShape = new Shape()

          _tmpShape.curves = _tmpPath.curves
          shapes.push(_tmpShape)
        }

        return shapes
      }

      function isPointInsidePolygon(inPt, inPolygon) {
        var 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

        var inside = false

        for (var p = polyLen - 1, q = 0; q < polyLen; p = q++) {
          var edgeLowPt = inPolygon[p]
          var edgeHighPt = inPolygon[q]
          var edgeDx = edgeHighPt.x - edgeLowPt.x
          var 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 {
              var 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
      }

      var isClockWise = ShapeUtils.isClockWise
      var subPaths = this.subPaths
      if (subPaths.length === 0) return []
      if (noHoles === true) return toShapesNoHoles(subPaths)
      var solid, tmpPath, tmpShape
      var shapes = []

      if (subPaths.length === 1) {
        tmpPath = subPaths[0]
        tmpShape = new Shape()
        tmpShape.curves = tmpPath.curves
        shapes.push(tmpShape)
        return shapes
      }

      var holesFirst = !isClockWise(subPaths[0].getPoints())
      holesFirst = isCCW ? !holesFirst : holesFirst // console.log("Holes first", holesFirst);

      var betterShapeHoles = []
      var newShapes = []
      var newShapeHoles = []
      var mainIdx = 0
      var tmpPoints
      newShapes[mainIdx] = undefined
      newShapeHoles[mainIdx] = []

      for (var 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 Shape(),
            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]
          }) //console.log('ccw', i);
        }
      } // only Holes? -> probably all Shapes with wrong orientation

      if (!newShapes[0]) return toShapesNoHoles(subPaths)

      if (newShapes.length > 1) {
        var ambiguous = false
        var toChange = []

        for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++) {
          betterShapeHoles[sIdx] = []
        }

        for (var _sIdx = 0, _sLen = newShapes.length; _sIdx < _sLen; _sIdx++) {
          var sho = newShapeHoles[_sIdx]

          for (var hIdx = 0; hIdx < sho.length; hIdx++) {
            var ho = sho[hIdx]
            var hole_unassigned = true

            for (var s2Idx = 0; s2Idx < newShapes.length; s2Idx++) {
              if (isPointInsidePolygon(ho.p, newShapes[s2Idx].p)) {
                if (_sIdx !== s2Idx)
                  toChange.push({
                    froms: _sIdx,
                    tos: s2Idx,
                    hole: hIdx
                  })

                if (hole_unassigned) {
                  hole_unassigned = false
                  betterShapeHoles[s2Idx].push(ho)
                } else {
                  ambiguous = true
                }
              }
            }

            if (hole_unassigned) {
              betterShapeHoles[_sIdx].push(ho)
            }
          }
        } // console.log("ambiguous: ", ambiguous);

        if (toChange.length > 0) {
          // console.log("to change: ", toChange);
          if (!ambiguous) newShapeHoles = betterShapeHoles
        }
      }

      var tmpHoles

      for (var _i = 0, il = newShapes.length; _i < il; _i++) {
        tmpShape = newShapes[_i].s
        shapes.push(tmpShape)
        tmpHoles = newShapeHoles[_i]

        for (var j = 0, jl = tmpHoles.length; j < jl; j++) {
          tmpShape.holes.push(tmpHoles[j].h)
        }
      } //console.log("shape", shapes);

      return shapes
    }
  })

  function Font(data) {
    this.type = 'Font'
    this.data = data
  }

  Object.assign(Font.prototype, {
    isFont: true,
    generateShapes: function generateShapes(text, size) {
      if (size === void 0) {
        size = 100
      }

      var shapes = []
      var paths = createPaths(text, size, this.data)

      for (var p = 0, pl = paths.length; p < pl; p++) {
        Array.prototype.push.apply(shapes, paths[p].toShapes())
      }

      return shapes
    }
  })

  function createPaths(text, size, data) {
    var chars = Array.from ? Array.from(text) : String(text).split('') // workaround for IE11, see #13988

    var scale = size / data.resolution
    var line_height = (data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness) * scale
    var paths = []
    var offsetX = 0,
      offsetY = 0

    for (var i = 0; i < chars.length; i++) {
      var char = chars[i]

      if (char === '\n') {
        offsetX = 0
        offsetY -= line_height
      } else {
        var ret = createPath(char, scale, offsetX, offsetY, data)
        offsetX += ret.offsetX
        paths.push(ret.path)
      }
    }

    return paths
  }

  function createPath(char, scale, offsetX, offsetY, data) {
    var glyph = data.glyphs[char] || data.glyphs['?']

    if (!glyph) {
      console.error('THREE.Font: character "' + char + '" does not exists in font family ' + data.familyName + '.')
      return
    }

    var path = new ShapePath()
    var x, y, cpx, cpy, cpx1, cpy1, cpx2, cpy2

    if (glyph.o) {
      var outline = glyph._cachedOutline || (glyph._cachedOutline = glyph.o.split(' '))

      for (var i = 0, l = outline.length; i < l; ) {
        var action = outline[i++]

        switch (action) {
          case 'm':
            // moveTo
            x = outline[i++] * scale + offsetX
            y = outline[i++] * scale + offsetY
            path.moveTo(x, y)
            break

          case 'l':
            // lineTo
            x = outline[i++] * scale + offsetX
            y = outline[i++] * scale + offsetY
            path.lineTo(x, y)
            break

          case 'q':
            // quadraticCurveTo
            cpx = outline[i++] * scale + offsetX
            cpy = outline[i++] * scale + offsetY
            cpx1 = outline[i++] * scale + offsetX
            cpy1 = outline[i++] * scale + offsetY
            path.quadraticCurveTo(cpx1, cpy1, cpx, cpy)
            break

          case 'b':
            // bezierCurveTo
            cpx = outline[i++] * scale + offsetX
            cpy = outline[i++] * scale + offsetY
            cpx1 = outline[i++] * scale + offsetX
            cpy1 = outline[i++] * scale + offsetY
            cpx2 = outline[i++] * scale + offsetX
            cpy2 = outline[i++] * scale + offsetY
            path.bezierCurveTo(cpx1, cpy1, cpx2, cpy2, cpx, cpy)
            break
        }
      }
    }

    return {
      offsetX: glyph.ha * scale,
      path: path
    }
  }

  function FontLoader(manager) {
    Loader.call(this, manager)
  }

  FontLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: FontLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var loader = new FileLoader(this.manager)
      loader.setPath(this.path)
      loader.setRequestHeader(this.requestHeader)
      loader.setWithCredentials(scope.withCredentials)
      loader.load(
        url,
        function (text) {
          var json

          try {
            json = JSON.parse(text)
          } catch (e) {
            console.warn('THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead.')
            json = JSON.parse(text.substring(65, text.length - 2))
          }

          var font = scope.parse(json)
          if (onLoad) onLoad(font)
        },
        onProgress,
        onError
      )
    },
    parse: function parse(json) {
      return new Font(json)
    }
  })

  var _context

  var AudioContext = {
    getContext: function getContext() {
      if (_context === undefined) {
        _context = new (window.AudioContext || window.webkitAudioContext)()
      }

      return _context
    },
    setContext: function setContext(value) {
      _context = value
    }
  }

  function AudioLoader(manager) {
    Loader.call(this, manager)
  }

  AudioLoader.prototype = Object.assign(Object.create(Loader.prototype), {
    constructor: AudioLoader,
    load: function load(url, onLoad, onProgress, onError) {
      var scope = this
      var loader = new FileLoader(scope.manager)
      loader.setResponseType('arraybuffer')
      loader.setPath(scope.path)
      loader.setRequestHeader(scope.requestHeader)
      loader.setWithCredentials(scope.withCredentials)
      loader.load(
        url,
        function (buffer) {
          try {
            // Create a copy of the buffer. The `decodeAudioData` method
            // detaches the buffer when complete, preventing reuse.
            var bufferCopy = buffer.slice(0)
            var context = AudioContext.getContext()
            context.decodeAudioData(bufferCopy, function (audioBuffer) {
              onLoad(audioBuffer)
            })
          } catch (e) {
            if (onError) {
              onError(e)
            } else {
              console.error(e)
            }

            scope.manager.itemError(url)
          }
        },
        onProgress,
        onError
      )
    }
  })

  function HemisphereLightProbe(skyColor, groundColor, intensity) {
    LightProbe.call(this, undefined, intensity)
    var color1 = new Color().set(skyColor)
    var color2 = new Color().set(groundColor)
    var sky = new Vector3(color1.r, color1.g, color1.b)
    var ground = new Vector3(color2.r, color2.g, color2.b) // without extra factor of PI in the shader, should = 1 / Math.sqrt( Math.PI );

    var c0 = Math.sqrt(Math.PI)
    var c1 = c0 * Math.sqrt(0.75)
    this.sh.coefficients[0].copy(sky).add(ground).multiplyScalar(c0)
    this.sh.coefficients[1].copy(sky).sub(ground).multiplyScalar(c1)
  }

  HemisphereLightProbe.prototype = Object.assign(Object.create(LightProbe.prototype), {
    constructor: HemisphereLightProbe,
    isHemisphereLightProbe: true,
    copy: function copy(source) {
      // modifying colors not currently supported
      LightProbe.prototype.copy.call(this, source)
      return this
    },
    toJSON: function toJSON(meta) {
      var data = LightProbe.prototype.toJSON.call(this, meta) // data.sh = this.sh.toArray(); // todo

      return data
    }
  })

  function AmbientLightProbe(color, intensity) {
    LightProbe.call(this, undefined, intensity)
    var color1 = new Color().set(color) // without extra factor of PI in the shader, would be 2 / Math.sqrt( Math.PI );

    this.sh.coefficients[0].set(color1.r, color1.g, color1.b).multiplyScalar(2 * Math.sqrt(Math.PI))
  }

  AmbientLightProbe.prototype = Object.assign(Object.create(LightProbe.prototype), {
    constructor: AmbientLightProbe,
    isAmbientLightProbe: true,
    copy: function copy(source) {
      // modifying color not currently supported
      LightProbe.prototype.copy.call(this, source)
      return this
    },
    toJSON: function toJSON(meta) {
      var data = LightProbe.prototype.toJSON.call(this, meta) // data.sh = this.sh.toArray(); // todo

      return data
    }
  })

  var _eyeRight = new Matrix4()

  var _eyeLeft = new Matrix4()

  function StereoCamera() {
    this.type = 'StereoCamera'
    this.aspect = 1
    this.eyeSep = 0.064
    this.cameraL = new PerspectiveCamera()
    this.cameraL.layers.enable(1)
    this.cameraL.matrixAutoUpdate = false
    this.cameraR = new PerspectiveCamera()
    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
    }
  }

  Object.assign(StereoCamera.prototype, {
    update: function update(camera) {
      var cache = this._cache
      var 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/

        var projectionMatrix = camera.projectionMatrix.clone()
        var eyeSepHalf = cache.eyeSep / 2
        var eyeSepOnProjection = (eyeSepHalf * cache.near) / cache.focus
        var ymax = (cache.near * Math.tan(MathUtils.DEG2RAD * cache.fov * 0.5)) / cache.zoom
        var xmin, xmax // translate xOffset

        _eyeLeft.elements[12] = -eyeSepHalf
        _eyeRight.elements[12] = eyeSepHalf // for left eye

        xmin = -ymax * cache.aspect + eyeSepOnProjection
        xmax = ymax * cache.aspect + eyeSepOnProjection
        projectionMatrix.elements[0] = (2 * cache.near) / (xmax - xmin)
        projectionMatrix.elements[8] = (xmax + xmin) / (xmax - xmin)
        this.cameraL.projectionMatrix.copy(projectionMatrix) // for right eye

        xmin = -ymax * cache.aspect - eyeSepOnProjection
        xmax = ymax * cache.aspect - eyeSepOnProjection
        projectionMatrix.elements[0] = (2 * cache.near) / (xmax - xmin)
        projectionMatrix.elements[8] = (xmax + xmin) / (xmax - xmin)
        this.cameraR.projectionMatrix.copy(projectionMatrix)
      }

      this.cameraL.matrixWorld.copy(camera.matrixWorld).multiply(_eyeLeft)
      this.cameraR.matrixWorld.copy(camera.matrixWorld).multiply(_eyeRight)
    }
  })

  var Clock = /*#__PURE__*/ (function () {
    function Clock(autoStart) {
      this.autoStart = autoStart !== undefined ? autoStart : true
      this.startTime = 0
      this.oldTime = 0
      this.elapsedTime = 0
      this.running = false
    }

    var _proto = Clock.prototype

    _proto.start = function start() {
      this.startTime = now()
      this.oldTime = this.startTime
      this.elapsedTime = 0
      this.running = true
    }

    _proto.stop = function stop() {
      this.getElapsedTime()
      this.running = false
      this.autoStart = false
    }

    _proto.getElapsedTime = function getElapsedTime() {
      this.getDelta()
      return this.elapsedTime
    }

    _proto.getDelta = function getDelta() {
      var diff = 0

      if (this.autoStart && !this.running) {
        this.start()
        return 0
      }

      if (this.running) {
        var newTime = now()
        diff = (newTime - this.oldTime) / 1000
        this.oldTime = newTime
        this.elapsedTime += diff
      }

      return diff
    }

    return Clock
  })()

  function now() {
    return (typeof performance === 'undefined' ? Date : performance).now() // see #10732
  }

  var _position$2 = /*@__PURE__*/ new Vector3()

  var _quaternion$3 = /*@__PURE__*/ new Quaternion()

  var _scale$1 = /*@__PURE__*/ new Vector3()

  var _orientation = /*@__PURE__*/ new Vector3()

  var AudioListener = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(AudioListener, _Object3D)

    function AudioListener() {
      var _this

      _this = _Object3D.call(this) || this
      _this.type = 'AudioListener'
      _this.context = AudioContext.getContext()
      _this.gain = _this.context.createGain()

      _this.gain.connect(_this.context.destination)

      _this.filter = null
      _this.timeDelta = 0 // private

      _this._clock = new Clock()
      return _this
    }

    var _proto = AudioListener.prototype

    _proto.getInput = function getInput() {
      return this.gain
    }

    _proto.removeFilter = function 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
    }

    _proto.getFilter = function getFilter() {
      return this.filter
    }

    _proto.setFilter = function 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
    }

    _proto.getMasterVolume = function getMasterVolume() {
      return this.gain.gain.value
    }

    _proto.setMasterVolume = function setMasterVolume(value) {
      this.gain.gain.setTargetAtTime(value, this.context.currentTime, 0.01)
      return this
    }

    _proto.updateMatrixWorld = function updateMatrixWorld(force) {
      _Object3D.prototype.updateMatrixWorld.call(this, force)

      var listener = this.context.listener
      var up = this.up
      this.timeDelta = this._clock.getDelta()
      this.matrixWorld.decompose(_position$2, _quaternion$3, _scale$1)

      _orientation.set(0, 0, -1).applyQuaternion(_quaternion$3)

      if (listener.positionX) {
        // code path for Chrome (see #14393)
        var endTime = this.context.currentTime + this.timeDelta
        listener.positionX.linearRampToValueAtTime(_position$2.x, endTime)
        listener.positionY.linearRampToValueAtTime(_position$2.y, endTime)
        listener.positionZ.linearRampToValueAtTime(_position$2.z, endTime)
        listener.forwardX.linearRampToValueAtTime(_orientation.x, endTime)
        listener.forwardY.linearRampToValueAtTime(_orientation.y, endTime)
        listener.forwardZ.linearRampToValueAtTime(_orientation.z, endTime)
        listener.upX.linearRampToValueAtTime(up.x, endTime)
        listener.upY.linearRampToValueAtTime(up.y, endTime)
        listener.upZ.linearRampToValueAtTime(up.z, endTime)
      } else {
        listener.setPosition(_position$2.x, _position$2.y, _position$2.z)
        listener.setOrientation(_orientation.x, _orientation.y, _orientation.z, up.x, up.y, up.z)
      }
    }

    return AudioListener
  })(Object3D)

  var Audio = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(Audio, _Object3D)

    function Audio(listener) {
      var _this

      _this = _Object3D.call(this) || this
      _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 = []
      return _this
    }

    var _proto = Audio.prototype

    _proto.getOutput = function getOutput() {
      return this.gain
    }

    _proto.setNodeSource = function setNodeSource(audioNode) {
      this.hasPlaybackControl = false
      this.sourceType = 'audioNode'
      this.source = audioNode
      this.connect()
      return this
    }

    _proto.setMediaElementSource = function setMediaElementSource(mediaElement) {
      this.hasPlaybackControl = false
      this.sourceType = 'mediaNode'
      this.source = this.context.createMediaElementSource(mediaElement)
      this.connect()
      return this
    }

    _proto.setMediaStreamSource = function setMediaStreamSource(mediaStream) {
      this.hasPlaybackControl = false
      this.sourceType = 'mediaStreamNode'
      this.source = this.context.createMediaStreamSource(mediaStream)
      this.connect()
      return this
    }

    _proto.setBuffer = function setBuffer(audioBuffer) {
      this.buffer = audioBuffer
      this.sourceType = 'buffer'
      if (this.autoplay) this.play()
      return this
    }

    _proto.play = function play(delay) {
      if (delay === void 0) {
        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
      var 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()
    }

    _proto.pause = function 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
    }

    _proto.stop = function stop() {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return
      }

      this._progress = 0
      this.source.stop()
      this.source.onended = null
      this.isPlaying = false
      return this
    }

    _proto.connect = function connect() {
      if (this.filters.length > 0) {
        this.source.connect(this.filters[0])

        for (var 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
    }

    _proto.disconnect = function disconnect() {
      if (this.filters.length > 0) {
        this.source.disconnect(this.filters[0])

        for (var 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
    }

    _proto.getFilters = function getFilters() {
      return this.filters
    }

    _proto.setFilters = function setFilters(value) {
      if (!value) value = []

      if (this._connected === true) {
        this.disconnect()
        this.filters = value.slice()
        this.connect()
      } else {
        this.filters = value.slice()
      }

      return this
    }

    _proto.setDetune = function setDetune(value) {
      this.detune = value
      if (this.source.detune === undefined) return // only set detune when available

      if (this.isPlaying === true) {
        this.source.detune.setTargetAtTime(this.detune, this.context.currentTime, 0.01)
      }

      return this
    }

    _proto.getDetune = function getDetune() {
      return this.detune
    }

    _proto.getFilter = function getFilter() {
      return this.getFilters()[0]
    }

    _proto.setFilter = function setFilter(filter) {
      return this.setFilters(filter ? [filter] : [])
    }

    _proto.setPlaybackRate = function 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
    }

    _proto.getPlaybackRate = function getPlaybackRate() {
      return this.playbackRate
    }

    _proto.onEnded = function onEnded() {
      this.isPlaying = false
    }

    _proto.getLoop = function getLoop() {
      if (this.hasPlaybackControl === false) {
        console.warn('THREE.Audio: this Audio has no playback control.')
        return false
      }

      return this.loop
    }

    _proto.setLoop = function 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
    }

    _proto.setLoopStart = function setLoopStart(value) {
      this.loopStart = value
      return this
    }

    _proto.setLoopEnd = function setLoopEnd(value) {
      this.loopEnd = value
      return this
    }

    _proto.getVolume = function getVolume() {
      return this.gain.gain.value
    }

    _proto.setVolume = function setVolume(value) {
      this.gain.gain.setTargetAtTime(value, this.context.currentTime, 0.01)
      return this
    }

    return Audio
  })(Object3D)

  var _position$3 = /*@__PURE__*/ new Vector3()

  var _quaternion$4 = /*@__PURE__*/ new Quaternion()

  var _scale$2 = /*@__PURE__*/ new Vector3()

  var _orientation$1 = /*@__PURE__*/ new Vector3()

  var PositionalAudio = /*#__PURE__*/ (function (_Audio) {
    _inheritsLoose(PositionalAudio, _Audio)

    function PositionalAudio(listener) {
      var _this

      _this = _Audio.call(this, listener) || this
      _this.panner = _this.context.createPanner()
      _this.panner.panningModel = 'HRTF'

      _this.panner.connect(_this.gain)

      return _this
    }

    var _proto = PositionalAudio.prototype

    _proto.getOutput = function getOutput() {
      return this.panner
    }

    _proto.getRefDistance = function getRefDistance() {
      return this.panner.refDistance
    }

    _proto.setRefDistance = function setRefDistance(value) {
      this.panner.refDistance = value
      return this
    }

    _proto.getRolloffFactor = function getRolloffFactor() {
      return this.panner.rolloffFactor
    }

    _proto.setRolloffFactor = function setRolloffFactor(value) {
      this.panner.rolloffFactor = value
      return this
    }

    _proto.getDistanceModel = function getDistanceModel() {
      return this.panner.distanceModel
    }

    _proto.setDistanceModel = function setDistanceModel(value) {
      this.panner.distanceModel = value
      return this
    }

    _proto.getMaxDistance = function getMaxDistance() {
      return this.panner.maxDistance
    }

    _proto.setMaxDistance = function setMaxDistance(value) {
      this.panner.maxDistance = value
      return this
    }

    _proto.setDirectionalCone = function setDirectionalCone(coneInnerAngle, coneOuterAngle, coneOuterGain) {
      this.panner.coneInnerAngle = coneInnerAngle
      this.panner.coneOuterAngle = coneOuterAngle
      this.panner.coneOuterGain = coneOuterGain
      return this
    }

    _proto.updateMatrixWorld = function updateMatrixWorld(force) {
      _Audio.prototype.updateMatrixWorld.call(this, force)

      if (this.hasPlaybackControl === true && this.isPlaying === false) return
      this.matrixWorld.decompose(_position$3, _quaternion$4, _scale$2)

      _orientation$1.set(0, 0, 1).applyQuaternion(_quaternion$4)

      var panner = this.panner

      if (panner.positionX) {
        // code path for Chrome and Firefox (see #14393)
        var endTime = this.context.currentTime + this.listener.timeDelta
        panner.positionX.linearRampToValueAtTime(_position$3.x, endTime)
        panner.positionY.linearRampToValueAtTime(_position$3.y, endTime)
        panner.positionZ.linearRampToValueAtTime(_position$3.z, endTime)
        panner.orientationX.linearRampToValueAtTime(_orientation$1.x, endTime)
        panner.orientationY.linearRampToValueAtTime(_orientation$1.y, endTime)
        panner.orientationZ.linearRampToValueAtTime(_orientation$1.z, endTime)
      } else {
        panner.setPosition(_position$3.x, _position$3.y, _position$3.z)
        panner.setOrientation(_orientation$1.x, _orientation$1.y, _orientation$1.z)
      }
    }

    return PositionalAudio
  })(Audio)

  var AudioAnalyser = /*#__PURE__*/ (function () {
    function AudioAnalyser(audio, fftSize) {
      if (fftSize === void 0) {
        fftSize = 2048
      }

      this.analyser = audio.context.createAnalyser()
      this.analyser.fftSize = fftSize
      this.data = new Uint8Array(this.analyser.frequencyBinCount)
      audio.getOutput().connect(this.analyser)
    }

    var _proto = AudioAnalyser.prototype

    _proto.getFrequencyData = function getFrequencyData() {
      this.analyser.getByteFrequencyData(this.data)
      return this.data
    }

    _proto.getAverageFrequency = function getAverageFrequency() {
      var value = 0
      var data = this.getFrequencyData()

      for (var i = 0; i < data.length; i++) {
        value += data[i]
      }

      return value / data.length
    }

    return AudioAnalyser
  })()

  function PropertyMixer(binding, typeName, valueSize) {
    this.binding = binding
    this.valueSize = valueSize
    var 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
  }

  Object.assign(PropertyMixer.prototype, {
    // accumulate data in the 'incoming' region into 'accu<i>'
    accumulate: function 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
      var buffer = this.buffer,
        stride = this.valueSize,
        offset = accuIndex * stride + stride
      var currentWeight = this.cumulativeWeight

      if (currentWeight === 0) {
        // accuN := incoming * weight
        for (var i = 0; i !== stride; ++i) {
          buffer[offset + i] = buffer[i]
        }

        currentWeight = weight
      } else {
        // accuN := accuN + incoming * weight
        currentWeight += weight
        var mix = weight / currentWeight

        this._mixBufferRegion(buffer, offset, 0, mix, stride)
      }

      this.cumulativeWeight = currentWeight
    },
    // accumulate data in the 'incoming' region into 'add'
    accumulateAdditive: function accumulateAdditive(weight) {
      var 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: function apply(accuIndex) {
      var 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 )
        var 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 (var 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: function saveOriginalState() {
      var binding = this.binding
      var 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 (var 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: function restoreOriginalState() {
      var originalValueOffset = this.valueSize * 3
      this.binding.setValue(this.buffer, originalValueOffset)
    },
    _setAdditiveIdentityNumeric: function _setAdditiveIdentityNumeric() {
      var startIndex = this._addIndex * this.valueSize
      var endIndex = startIndex + this.valueSize

      for (var i = startIndex; i < endIndex; i++) {
        this.buffer[i] = 0
      }
    },
    _setAdditiveIdentityQuaternion: function _setAdditiveIdentityQuaternion() {
      this._setAdditiveIdentityNumeric()

      this.buffer[this._addIndex * this.valueSize + 3] = 1
    },
    _setAdditiveIdentityOther: function _setAdditiveIdentityOther() {
      var startIndex = this._origIndex * this.valueSize
      var targetIndex = this._addIndex * this.valueSize

      for (var i = 0; i < this.valueSize; i++) {
        this.buffer[targetIndex + i] = this.buffer[startIndex + i]
      }
    },
    // mix functions
    _select: function _select(buffer, dstOffset, srcOffset, t, stride) {
      if (t >= 0.5) {
        for (var i = 0; i !== stride; ++i) {
          buffer[dstOffset + i] = buffer[srcOffset + i]
        }
      }
    },
    _slerp: function _slerp(buffer, dstOffset, srcOffset, t) {
      Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t)
    },
    _slerpAdditive: function _slerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
      var workOffset = this._workIndex * stride // Store result in intermediate buffer offset

      Quaternion.multiplyQuaternionsFlat(buffer, workOffset, buffer, dstOffset, buffer, srcOffset) // Slerp to the intermediate result

      Quaternion.slerpFlat(buffer, dstOffset, buffer, dstOffset, buffer, workOffset, t)
    },
    _lerp: function _lerp(buffer, dstOffset, srcOffset, t, stride) {
      var s = 1 - t

      for (var i = 0; i !== stride; ++i) {
        var j = dstOffset + i
        buffer[j] = buffer[j] * s + buffer[srcOffset + i] * t
      }
    },
    _lerpAdditive: function _lerpAdditive(buffer, dstOffset, srcOffset, t, stride) {
      for (var i = 0; i !== stride; ++i) {
        var j = dstOffset + i
        buffer[j] = buffer[j] + buffer[srcOffset + i] * t
      }
    }
  })

  // Characters [].:/ are reserved for track binding syntax.
  var _RESERVED_CHARS_RE = '\\[\\]\\.:\\/'

  var _reservedRe = new RegExp('[' + _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.

  var _wordChar = '[^' + _RESERVED_CHARS_RE + ']'

  var _wordCharOrDot = '[^' + _RESERVED_CHARS_RE.replace('\\.', '') + ']' // Parent directories, delimited by '/' or ':'. Currently unused, but must
  // be matched to parse the rest of the track name.

  var _directoryRe = /((?:WC+[\/:])*)/.source.replace('WC', _wordChar) // Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.

  var _nodeRe = /(WCOD+)?/.source.replace('WCOD', _wordCharOrDot) // Object on target node, and accessor. May not contain reserved
  // characters. Accessor may contain any character except closing bracket.

  var _objectRe = /(?:\.(WC+)(?:\[(.+)\])?)?/.source.replace('WC', _wordChar) // Property and accessor. May not contain reserved characters. Accessor may
  // contain any non-bracket characters.

  var _propertyRe = /\.(WC+)(?:\[(.+)\])?/.source.replace('WC', _wordChar)

  var _trackRe = new RegExp('' + '^' + _directoryRe + _nodeRe + _objectRe + _propertyRe + '$')

  var _supportedObjectNames = ['material', 'materials', 'bones']

  function Composite(targetGroup, path, optionalParsedPath) {
    var parsedPath = optionalParsedPath || PropertyBinding.parseTrackName(path)
    this._targetGroup = targetGroup
    this._bindings = targetGroup.subscribe_(path, parsedPath)
  }

  Object.assign(Composite.prototype, {
    getValue: function getValue(array, offset) {
      this.bind() // bind all binding

      var firstValidIndex = this._targetGroup.nCachedObjects_,
        binding = this._bindings[firstValidIndex] // and only call .getValue on the first

      if (binding !== undefined) binding.getValue(array, offset)
    },
    setValue: function setValue(array, offset) {
      var bindings = this._bindings

      for (var i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) {
        bindings[i].setValue(array, offset)
      }
    },
    bind: function bind() {
      var bindings = this._bindings

      for (var i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) {
        bindings[i].bind()
      }
    },
    unbind: function unbind() {
      var bindings = this._bindings

      for (var i = this._targetGroup.nCachedObjects_, n = bindings.length; i !== n; ++i) {
        bindings[i].unbind()
      }
    }
  })

  function PropertyBinding(rootNode, path, parsedPath) {
    this.path = path
    this.parsedPath = parsedPath || PropertyBinding.parseTrackName(path)
    this.node = PropertyBinding.findNode(rootNode, this.parsedPath.nodeName) || rootNode
    this.rootNode = rootNode
  }

  Object.assign(PropertyBinding, {
    Composite: Composite,
    create: function create(root, path, parsedPath) {
      if (!(root && root.isAnimationObjectGroup)) {
        return new PropertyBinding(root, path, parsedPath)
      } else {
        return new PropertyBinding.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}
     */
    sanitizeNodeName: function sanitizeNodeName(name) {
      return name.replace(/\s/g, '_').replace(_reservedRe, '')
    },
    parseTrackName: function parseTrackName(trackName) {
      var matches = _trackRe.exec(trackName)

      if (!matches) {
        throw new Error('PropertyBinding: Cannot parse trackName: ' + trackName)
      }

      var results = {
        // directoryName: matches[ 1 ], // (tschw) currently unused
        nodeName: matches[2],
        objectName: matches[3],
        objectIndex: matches[4],
        propertyName: matches[5],
        // required
        propertyIndex: matches[6]
      }
      var lastDot = results.nodeName && results.nodeName.lastIndexOf('.')

      if (lastDot !== undefined && lastDot !== -1) {
        var 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 (_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
    },
    findNode: function findNode(root, nodeName) {
      if (!nodeName || nodeName === '' || nodeName === '.' || nodeName === -1 || nodeName === root.name || nodeName === root.uuid) {
        return root
      } // search into skeleton bones.

      if (root.skeleton) {
        var bone = root.skeleton.getBoneByName(nodeName)

        if (bone !== undefined) {
          return bone
        }
      } // search into node subtree.

      if (root.children) {
        var searchNodeSubtree = function searchNodeSubtree(children) {
          for (var i = 0; i < children.length; i++) {
            var childNode = children[i]

            if (childNode.name === nodeName || childNode.uuid === nodeName) {
              return childNode
            }

            var result = searchNodeSubtree(childNode.children)
            if (result) return result
          }

          return null
        }

        var subTreeNode = searchNodeSubtree(root.children)

        if (subTreeNode) {
          return subTreeNode
        }
      }

      return null
    }
  })
  Object.assign(PropertyBinding.prototype, {
    // prototype, continued
    // these are used to "bind" a nonexistent property
    _getValue_unavailable: function _getValue_unavailable() {},
    _setValue_unavailable: function _setValue_unavailable() {},
    BindingType: {
      Direct: 0,
      EntireArray: 1,
      ArrayElement: 2,
      HasFromToArray: 3
    },
    Versioning: {
      None: 0,
      NeedsUpdate: 1,
      MatrixWorldNeedsUpdate: 2
    },
    GetterByBindingType: [
      function getValue_direct(buffer, offset) {
        buffer[offset] = this.node[this.propertyName]
      },
      function getValue_array(buffer, offset) {
        var source = this.resolvedProperty

        for (var i = 0, n = source.length; i !== n; ++i) {
          buffer[offset++] = source[i]
        }
      },
      function getValue_arrayElement(buffer, offset) {
        buffer[offset] = this.resolvedProperty[this.propertyIndex]
      },
      function getValue_toArray(buffer, offset) {
        this.resolvedProperty.toArray(buffer, offset)
      }
    ],
    SetterByBindingTypeAndVersioning: [
      [
        // Direct
        function setValue_direct(buffer, offset) {
          this.targetObject[this.propertyName] = buffer[offset]
        },
        function setValue_direct_setNeedsUpdate(buffer, offset) {
          this.targetObject[this.propertyName] = buffer[offset]
          this.targetObject.needsUpdate = true
        },
        function setValue_direct_setMatrixWorldNeedsUpdate(buffer, offset) {
          this.targetObject[this.propertyName] = buffer[offset]
          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ],
      [
        // EntireArray
        function setValue_array(buffer, offset) {
          var dest = this.resolvedProperty

          for (var i = 0, n = dest.length; i !== n; ++i) {
            dest[i] = buffer[offset++]
          }
        },
        function setValue_array_setNeedsUpdate(buffer, offset) {
          var dest = this.resolvedProperty

          for (var i = 0, n = dest.length; i !== n; ++i) {
            dest[i] = buffer[offset++]
          }

          this.targetObject.needsUpdate = true
        },
        function setValue_array_setMatrixWorldNeedsUpdate(buffer, offset) {
          var dest = this.resolvedProperty

          for (var i = 0, n = dest.length; i !== n; ++i) {
            dest[i] = buffer[offset++]
          }

          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ],
      [
        // ArrayElement
        function setValue_arrayElement(buffer, offset) {
          this.resolvedProperty[this.propertyIndex] = buffer[offset]
        },
        function setValue_arrayElement_setNeedsUpdate(buffer, offset) {
          this.resolvedProperty[this.propertyIndex] = buffer[offset]
          this.targetObject.needsUpdate = true
        },
        function setValue_arrayElement_setMatrixWorldNeedsUpdate(buffer, offset) {
          this.resolvedProperty[this.propertyIndex] = buffer[offset]
          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ],
      [
        // HasToFromArray
        function setValue_fromArray(buffer, offset) {
          this.resolvedProperty.fromArray(buffer, offset)
        },
        function setValue_fromArray_setNeedsUpdate(buffer, offset) {
          this.resolvedProperty.fromArray(buffer, offset)
          this.targetObject.needsUpdate = true
        },
        function setValue_fromArray_setMatrixWorldNeedsUpdate(buffer, offset) {
          this.resolvedProperty.fromArray(buffer, offset)
          this.targetObject.matrixWorldNeedsUpdate = true
        }
      ]
    ],
    getValue: function getValue_unbound(targetArray, offset) {
      this.bind()
      this.getValue(targetArray, offset) // 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.
    },
    setValue: function getValue_unbound(sourceArray, offset) {
      this.bind()
      this.setValue(sourceArray, offset)
    },
    // create getter / setter pair for a property in the scene graph
    bind: function bind() {
      var targetObject = this.node
      var parsedPath = this.parsedPath
      var objectName = parsedPath.objectName
      var propertyName = parsedPath.propertyName
      var propertyIndex = parsedPath.propertyIndex

      if (!targetObject) {
        targetObject = PropertyBinding.findNode(this.rootNode, parsedPath.nodeName) || this.rootNode
        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.error('THREE.PropertyBinding: Trying to update node for track: ' + this.path + " but it wasn't found.")
        return
      }

      if (objectName) {
        var 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 (var i = 0; i < targetObject.length; i++) {
              if (targetObject[i].name === objectIndex) {
                objectIndex = i
                break
              }
            }

            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

      var nodeProperty = targetObject[propertyName]

      if (nodeProperty === undefined) {
        var 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

      var versioning = this.Versioning.None
      this.targetObject = targetObject

      if (targetObject.needsUpdate !== undefined) {
        // material
        versioning = this.Versioning.NeedsUpdate
      } else if (targetObject.matrixWorldNeedsUpdate !== undefined) {
        // node transform
        versioning = this.Versioning.MatrixWorldNeedsUpdate
      } // determine how the property gets bound

      var 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.isBufferGeometry) {
            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]
            }
          } else {
            console.error('THREE.PropertyBinding: Can not bind to morphTargetInfluences on THREE.Geometry. Use THREE.BufferGeometry instead.', this)
            return
          }
        }

        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: function 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
    }
  }) // DECLARE ALIAS AFTER assign prototype

  Object.assign(PropertyBinding.prototype, {
    // initial state of these methods that calls 'bind'
    _getValue_unbound: PropertyBinding.prototype.getValue,
    _setValue_unbound: PropertyBinding.prototype.setValue
  })

  /**
   *
   * 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.
   */

  function AnimationObjectGroup() {
    this.uuid = MathUtils.generateUUID() // cached objects followed by the active ones

    this._objects = Array.prototype.slice.call(arguments)
    this.nCachedObjects_ = 0 // threshold
    // note: read by PropertyBinding.Composite

    var indices = {}
    this._indicesByUUID = indices // for bookkeeping

    for (var 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

    var scope = this
    this.stats = {
      objects: {
        get total() {
          return scope._objects.length
        },

        get inUse() {
          return this.total - scope.nCachedObjects_
        }
      },

      get bindingsPerObject() {
        return scope._bindings.length
      }
    }
  }

  Object.assign(AnimationObjectGroup.prototype, {
    isAnimationObjectGroup: true,
    add: function add() {
      var objects = this._objects,
        indicesByUUID = this._indicesByUUID,
        paths = this._paths,
        parsedPaths = this._parsedPaths,
        bindings = this._bindings,
        nBindings = bindings.length
      var knownObject = undefined,
        nObjects = objects.length,
        nCachedObjects = this.nCachedObjects_

      for (var i = 0, n = arguments.length; i !== n; ++i) {
        var object = arguments[i],
          uuid = object.uuid
        var 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 (var j = 0, m = nBindings; j !== m; ++j) {
            bindings[j].push(new PropertyBinding(object, paths[j], parsedPaths[j]))
          }
        } else if (index < nCachedObjects) {
          knownObject = objects[index] // move existing object to the ACTIVE region

          var 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 (var _j = 0, _m = nBindings; _j !== _m; ++_j) {
            var bindingsForPath = bindings[_j],
              lastCached = bindingsForPath[firstActiveIndex]
            var 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 PropertyBinding(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: function remove() {
      var objects = this._objects,
        indicesByUUID = this._indicesByUUID,
        bindings = this._bindings,
        nBindings = bindings.length
      var nCachedObjects = this.nCachedObjects_

      for (var i = 0, n = arguments.length; i !== n; ++i) {
        var object = arguments[i],
          uuid = object.uuid,
          index = indicesByUUID[uuid]

        if (index !== undefined && index >= nCachedObjects) {
          // move existing object into the CACHED region
          var 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 (var j = 0, m = nBindings; j !== m; ++j) {
            var bindingsForPath = bindings[j],
              firstActive = bindingsForPath[lastCachedIndex],
              binding = bindingsForPath[index]
            bindingsForPath[index] = firstActive
            bindingsForPath[lastCachedIndex] = binding
          }
        }
      } // for arguments

      this.nCachedObjects_ = nCachedObjects
    },
    // remove & forget
    uncache: function uncache() {
      var objects = this._objects,
        indicesByUUID = this._indicesByUUID,
        bindings = this._bindings,
        nBindings = bindings.length
      var nCachedObjects = this.nCachedObjects_,
        nObjects = objects.length

      for (var i = 0, n = arguments.length; i !== n; ++i) {
        var 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
            var 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 (var j = 0, m = nBindings; j !== m; ++j) {
              var 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
            var _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 (var _j2 = 0, _m2 = nBindings; _j2 !== _m2; ++_j2) {
              var _bindingsForPath = bindings[_j2]
              _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_: function subscribe_(path, parsedPath) {
      // returns an array of bindings for the given path that is changed
      // according to the contained objects in the group
      var indicesByPath = this._bindingsIndicesByPath
      var index = indicesByPath[path]
      var bindings = this._bindings
      if (index !== undefined) return bindings[index]
      var 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 (var i = nCachedObjects, n = objects.length; i !== n; ++i) {
        var object = objects[i]
        bindingsForPath[i] = new PropertyBinding(object, path, parsedPath)
      }

      return bindingsForPath
    },
    unsubscribe_: function unsubscribe_(path) {
      // tells the group to forget about a property path and no longer
      // update the array previously obtained with 'subscribe_'
      var indicesByPath = this._bindingsIndicesByPath,
        index = indicesByPath[path]

      if (index !== undefined) {
        var 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()
      }
    }
  })

  var AnimationAction = /*#__PURE__*/ (function () {
    function AnimationAction(mixer, clip, localRoot, blendMode) {
      if (localRoot === void 0) {
        localRoot = null
      }

      if (blendMode === void 0) {
        blendMode = clip.blendMode
      }

      this._mixer = mixer
      this._clip = clip
      this._localRoot = localRoot
      this.blendMode = blendMode
      var tracks = clip.tracks,
        nTracks = tracks.length,
        interpolants = new Array(nTracks)
      var interpolantSettings = {
        endingStart: ZeroCurvatureEnding,
        endingEnd: ZeroCurvatureEnding
      }

      for (var i = 0; i !== nTracks; ++i) {
        var 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 = LoopRepeat
      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

    var _proto = AnimationAction.prototype

    _proto.play = function play() {
      this._mixer._activateAction(this)

      return this
    }

    _proto.stop = function stop() {
      this._mixer._deactivateAction(this)

      return this.reset()
    }

    _proto.reset = function 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()
    }

    _proto.isRunning = function isRunning() {
      return this.enabled && !this.paused && this.timeScale !== 0 && this._startTime === null && this._mixer._isActiveAction(this)
    } // return true when play has been called

    _proto.isScheduled = function isScheduled() {
      return this._mixer._isActiveAction(this)
    }

    _proto.startAt = function startAt(time) {
      this._startTime = time
      return this
    }

    _proto.setLoop = function 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

    _proto.setEffectiveWeight = function 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

    _proto.getEffectiveWeight = function getEffectiveWeight() {
      return this._effectiveWeight
    }

    _proto.fadeIn = function fadeIn(duration) {
      return this._scheduleFading(duration, 0, 1)
    }

    _proto.fadeOut = function fadeOut(duration) {
      return this._scheduleFading(duration, 1, 0)
    }

    _proto.crossFadeFrom = function crossFadeFrom(fadeOutAction, duration, warp) {
      fadeOutAction.fadeOut(duration)
      this.fadeIn(duration)

      if (warp) {
        var 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
    }

    _proto.crossFadeTo = function crossFadeTo(fadeInAction, duration, warp) {
      return fadeInAction.crossFadeFrom(this, duration, warp)
    }

    _proto.stopFading = function stopFading() {
      var 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

    _proto.setEffectiveTimeScale = function setEffectiveTimeScale(timeScale) {
      this.timeScale = timeScale
      this._effectiveTimeScale = this.paused ? 0 : timeScale
      return this.stopWarping()
    } // return the time scale considering warping and .paused

    _proto.getEffectiveTimeScale = function getEffectiveTimeScale() {
      return this._effectiveTimeScale
    }

    _proto.setDuration = function setDuration(duration) {
      this.timeScale = this._clip.duration / duration
      return this.stopWarping()
    }

    _proto.syncWith = function syncWith(action) {
      this.time = action.time
      this.timeScale = action.timeScale
      return this.stopWarping()
    }

    _proto.halt = function halt(duration) {
      return this.warp(this._effectiveTimeScale, 0, duration)
    }

    _proto.warp = function warp(startTimeScale, endTimeScale, duration) {
      var mixer = this._mixer,
        now = mixer.time,
        timeScale = this.timeScale
      var interpolant = this._timeScaleInterpolant

      if (interpolant === null) {
        interpolant = mixer._lendControlInterpolant()
        this._timeScaleInterpolant = interpolant
      }

      var times = interpolant.parameterPositions,
        values = interpolant.sampleValues
      times[0] = now
      times[1] = now + duration
      values[0] = startTimeScale / timeScale
      values[1] = endTimeScale / timeScale
      return this
    }

    _proto.stopWarping = function stopWarping() {
      var timeScaleInterpolant = this._timeScaleInterpolant

      if (timeScaleInterpolant !== null) {
        this._timeScaleInterpolant = null

        this._mixer._takeBackControlInterpolant(timeScaleInterpolant)
      }

      return this
    } // Object Accessors

    _proto.getMixer = function getMixer() {
      return this._mixer
    }

    _proto.getClip = function getClip() {
      return this._clip
    }

    _proto.getRoot = function getRoot() {
      return this._localRoot || this._mixer._root
    } // Interna

    _proto._update = function _update(time, deltaTime, timeDirection, accuIndex) {
      // called by the mixer
      if (!this.enabled) {
        // call ._updateWeight() to update ._effectiveWeight
        this._updateWeight(time)

        return
      }

      var startTime = this._startTime

      if (startTime !== null) {
        // check for scheduled start of action
        var timeRunning = (time - startTime) * timeDirection

        if (timeRunning < 0 || timeDirection === 0) {
          return // yet to come / don't decide when delta = 0
        } // start

        this._startTime = null // unschedule

        deltaTime = timeDirection * timeRunning
      } // apply time scale and advance time

      deltaTime *= this._updateTimeScale(time)

      var clipTime = this._updateTime(deltaTime) // note: _updateTime may disable the action resulting in
      // an effective weight of 0

      var weight = this._updateWeight(time)

      if (weight > 0) {
        var _interpolants = this._interpolants
        var propertyMixers = this._propertyBindings

        switch (this.blendMode) {
          case AdditiveAnimationBlendMode:
            for (var j = 0, m = _interpolants.length; j !== m; ++j) {
              _interpolants[j].evaluate(clipTime)

              propertyMixers[j].accumulateAdditive(weight)
            }

            break

          case NormalAnimationBlendMode:
          default:
            for (var _j = 0, _m = _interpolants.length; _j !== _m; ++_j) {
              _interpolants[_j].evaluate(clipTime)

              propertyMixers[_j].accumulate(accuIndex, weight)
            }
        }
      }
    }

    _proto._updateWeight = function _updateWeight(time) {
      var weight = 0

      if (this.enabled) {
        weight = this.weight
        var interpolant = this._weightInterpolant

        if (interpolant !== null) {
          var 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
    }

    _proto._updateTimeScale = function _updateTimeScale(time) {
      var timeScale = 0

      if (!this.paused) {
        timeScale = this.timeScale
        var interpolant = this._timeScaleInterpolant

        if (interpolant !== null) {
          var 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
    }

    _proto._updateTime = function _updateTime(deltaTime) {
      var duration = this._clip.duration
      var loop = this.loop
      var time = this.time + deltaTime
      var loopCount = this._loopCount
      var pingPong = loop === LoopPingPong

      if (deltaTime === 0) {
        if (loopCount === -1) return time
        return pingPong && (loopCount & 1) === 1 ? duration - time : time
      }

      if (loop === LoopOnce) {
        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 {
        // repetitive Repeat or PingPong
        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
          var loopDelta = Math.floor(time / duration) // signed

          time -= duration * loopDelta
          loopCount += Math.abs(loopDelta)
          var 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
              var 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
    }

    _proto._setEndings = function _setEndings(atStart, atEnd, pingPong) {
      var settings = this._interpolantSettings

      if (pingPong) {
        settings.endingStart = ZeroSlopeEnding
        settings.endingEnd = ZeroSlopeEnding
      } else {
        // assuming for LoopOnce atStart == atEnd == true
        if (atStart) {
          settings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding
        } else {
          settings.endingStart = WrapAroundEnding
        }

        if (atEnd) {
          settings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding
        } else {
          settings.endingEnd = WrapAroundEnding
        }
      }
    }

    _proto._scheduleFading = function _scheduleFading(duration, weightNow, weightThen) {
      var mixer = this._mixer,
        now = mixer.time
      var interpolant = this._weightInterpolant

      if (interpolant === null) {
        interpolant = mixer._lendControlInterpolant()
        this._weightInterpolant = interpolant
      }

      var times = interpolant.parameterPositions,
        values = interpolant.sampleValues
      times[0] = now
      values[0] = weightNow
      times[1] = now + duration
      values[1] = weightThen
      return this
    }

    return AnimationAction
  })()

  function AnimationMixer(root) {
    this._root = root

    this._initMemoryManager()

    this._accuIndex = 0
    this.time = 0
    this.timeScale = 1.0
  }

  AnimationMixer.prototype = Object.assign(Object.create(EventDispatcher.prototype), {
    constructor: AnimationMixer,
    _bindAction: function _bindAction(action, prototypeAction) {
      var root = action._localRoot || this._root,
        tracks = action._clip.tracks,
        nTracks = tracks.length,
        bindings = action._propertyBindings,
        interpolants = action._interpolants,
        rootUuid = root.uuid,
        bindingsByRoot = this._bindingsByRootAndName
      var bindingsByName = bindingsByRoot[rootUuid]

      if (bindingsByName === undefined) {
        bindingsByName = {}
        bindingsByRoot[rootUuid] = bindingsByName
      }

      for (var i = 0; i !== nTracks; ++i) {
        var track = tracks[i],
          trackName = track.name
        var binding = bindingsByName[trackName]

        if (binding !== undefined) {
          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
          }

          var path = prototypeAction && prototypeAction._propertyBindings[i].binding.parsedPath
          binding = new PropertyMixer(PropertyBinding.create(root, trackName, path), track.ValueTypeName, track.getValueSize())
          ++binding.referenceCount

          this._addInactiveBinding(binding, rootUuid, trackName)

          bindings[i] = binding
        }

        interpolants[i].resultBuffer = binding.buffer
      }
    },
    _activateAction: function _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
          var 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)
        }

        var bindings = action._propertyBindings // increment reference counts / sort out state

        for (var i = 0, n = bindings.length; i !== n; ++i) {
          var binding = bindings[i]

          if (binding.useCount++ === 0) {
            this._lendBinding(binding)

            binding.saveOriginalState()
          }
        }

        this._lendAction(action)
      }
    },
    _deactivateAction: function _deactivateAction(action) {
      if (this._isActiveAction(action)) {
        var bindings = action._propertyBindings // decrement reference counts / sort out state

        for (var i = 0, n = bindings.length; i !== n; ++i) {
          var binding = bindings[i]

          if (--binding.useCount === 0) {
            binding.restoreOriginalState()

            this._takeBackBinding(binding)
          }
        }

        this._takeBackAction(action)
      }
    },
    // Memory manager
    _initMemoryManager: function _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
      var 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: function _isActiveAction(action) {
      var index = action._cacheIndex
      return index !== null && index < this._nActiveActions
    },
    _addInactiveAction: function _addInactiveAction(action, clipUuid, rootUuid) {
      var actions = this._actions,
        actionsByClip = this._actionsByClip
      var actionsForClip = actionsByClip[clipUuid]

      if (actionsForClip === undefined) {
        actionsForClip = {
          knownActions: [action],
          actionByRoot: {}
        }
        action._byClipCacheIndex = 0
        actionsByClip[clipUuid] = actionsForClip
      } else {
        var knownActions = actionsForClip.knownActions
        action._byClipCacheIndex = knownActions.length
        knownActions.push(action)
      }

      action._cacheIndex = actions.length
      actions.push(action)
      actionsForClip.actionByRoot[rootUuid] = action
    },
    _removeInactiveAction: function _removeInactiveAction(action) {
      var actions = this._actions,
        lastInactiveAction = actions[actions.length - 1],
        cacheIndex = action._cacheIndex
      lastInactiveAction._cacheIndex = cacheIndex
      actions[cacheIndex] = lastInactiveAction
      actions.pop()
      action._cacheIndex = null
      var 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
      var actionByRoot = actionsForClip.actionByRoot,
        rootUuid = (action._localRoot || this._root).uuid
      delete actionByRoot[rootUuid]

      if (knownActionsForClip.length === 0) {
        delete actionsByClip[clipUuid]
      }

      this._removeInactiveBindingsForAction(action)
    },
    _removeInactiveBindingsForAction: function _removeInactiveBindingsForAction(action) {
      var bindings = action._propertyBindings

      for (var i = 0, n = bindings.length; i !== n; ++i) {
        var binding = bindings[i]

        if (--binding.referenceCount === 0) {
          this._removeInactiveBinding(binding)
        }
      }
    },
    _lendAction: function _lendAction(action) {
      // [ active actions |	inactive actions	]
      // [	active actions >| inactive actions ]
      //								 s				a
      //									<-swap->
      //								 a				s
      var 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: function _takeBackAction(action) {
      // [	active actions	| inactive actions ]
      // [ active actions |< inactive actions	]
      //				a				s
      //				 <-swap->
      //				s				a
      var 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: function _addInactiveBinding(binding, rootUuid, trackName) {
      var bindingsByRoot = this._bindingsByRootAndName,
        bindings = this._bindings
      var bindingByName = bindingsByRoot[rootUuid]

      if (bindingByName === undefined) {
        bindingByName = {}
        bindingsByRoot[rootUuid] = bindingByName
      }

      bindingByName[trackName] = binding
      binding._cacheIndex = bindings.length
      bindings.push(binding)
    },
    _removeInactiveBinding: function _removeInactiveBinding(binding) {
      var 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: function _lendBinding(binding) {
      var 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: function _takeBackBinding(binding) {
      var 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: function _lendControlInterpolant() {
      var interpolants = this._controlInterpolants,
        lastActiveIndex = this._nActiveControlInterpolants++
      var interpolant = interpolants[lastActiveIndex]

      if (interpolant === undefined) {
        interpolant = new LinearInterpolant(new Float32Array(2), new Float32Array(2), 1, this._controlInterpolantsResultBuffer)
        interpolant.__cacheIndex = lastActiveIndex
        interpolants[lastActiveIndex] = interpolant
      }

      return interpolant
    },
    _takeBackControlInterpolant: function _takeBackControlInterpolant(interpolant) {
      var interpolants = this._controlInterpolants,
        prevIndex = interpolant.__cacheIndex,
        firstInactiveIndex = --this._nActiveControlInterpolants,
        lastActiveInterpolant = interpolants[firstInactiveIndex]
      interpolant.__cacheIndex = firstInactiveIndex
      interpolants[firstInactiveIndex] = interpolant
      lastActiveInterpolant.__cacheIndex = prevIndex
      interpolants[prevIndex] = lastActiveInterpolant
    },
    _controlInterpolantsResultBuffer: new Float32Array(1),
    // 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: function clipAction(clip, optionalRoot, blendMode) {
      var root = optionalRoot || this._root,
        rootUuid = root.uuid
      var clipObject = typeof clip === 'string' ? AnimationClip.findByName(root, clip) : clip
      var clipUuid = clipObject !== null ? clipObject.uuid : clip
      var actionsForClip = this._actionsByClip[clipUuid]
      var prototypeAction = null

      if (blendMode === undefined) {
        if (clipObject !== null) {
          blendMode = clipObject.blendMode
        } else {
          blendMode = NormalAnimationBlendMode
        }
      }

      if (actionsForClip !== undefined) {
        var 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

      var newAction = new AnimationAction(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: function existingAction(clip, optionalRoot) {
      var root = optionalRoot || this._root,
        rootUuid = root.uuid,
        clipObject = typeof clip === 'string' ? AnimationClip.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: function stopAllAction() {
      var actions = this._actions,
        nActions = this._nActiveActions

      for (var i = nActions - 1; i >= 0; --i) {
        actions[i].stop()
      }

      return this
    },
    // advance the time and update apply the animation
    update: function update(deltaTime) {
      deltaTime *= this.timeScale
      var actions = this._actions,
        nActions = this._nActiveActions,
        time = (this.time += deltaTime),
        timeDirection = Math.sign(deltaTime),
        accuIndex = (this._accuIndex ^= 1) // run active actions

      for (var i = 0; i !== nActions; ++i) {
        var action = actions[i]

        action._update(time, deltaTime, timeDirection, accuIndex)
      } // update scene graph

      var bindings = this._bindings,
        nBindings = this._nActiveBindings

      for (var _i = 0; _i !== nBindings; ++_i) {
        bindings[_i].apply(accuIndex)
      }

      return this
    },
    // Allows you to seek to a specific time in an animation.
    setTime: function setTime(timeInSeconds) {
      this.time = 0 // Zero out time attribute for AnimationMixer object;

      for (var 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: function getRoot() {
      return this._root
    },
    // free all resources specific to a particular clip
    uncacheClip: function uncacheClip(clip) {
      var 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
        var actionsToRemove = actionsForClip.knownActions

        for (var i = 0, n = actionsToRemove.length; i !== n; ++i) {
          var action = actionsToRemove[i]

          this._deactivateAction(action)

          var 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: function uncacheRoot(root) {
      var rootUuid = root.uuid,
        actionsByClip = this._actionsByClip

      for (var clipUuid in actionsByClip) {
        var actionByRoot = actionsByClip[clipUuid].actionByRoot,
          action = actionByRoot[rootUuid]

        if (action !== undefined) {
          this._deactivateAction(action)

          this._removeInactiveAction(action)
        }
      }

      var bindingsByRoot = this._bindingsByRootAndName,
        bindingByName = bindingsByRoot[rootUuid]

      if (bindingByName !== undefined) {
        for (var trackName in bindingByName) {
          var binding = bindingByName[trackName]
          binding.restoreOriginalState()

          this._removeInactiveBinding(binding)
        }
      }
    },
    // remove a targeted clip from the cache
    uncacheAction: function uncacheAction(clip, optionalRoot) {
      var action = this.existingAction(clip, optionalRoot)

      if (action !== null) {
        this._deactivateAction(action)

        this._removeInactiveAction(action)
      }
    }
  })

  var Uniform = /*#__PURE__*/ (function () {
    function Uniform(value) {
      if (typeof value === 'string') {
        console.warn('THREE.Uniform: Type parameter is no longer needed.')
        value = arguments[1]
      }

      this.value = value
    }

    var _proto = Uniform.prototype

    _proto.clone = function clone() {
      return new Uniform(this.value.clone === undefined ? this.value : this.value.clone())
    }

    return Uniform
  })()

  function InstancedInterleavedBuffer(array, stride, meshPerAttribute) {
    InterleavedBuffer.call(this, array, stride)
    this.meshPerAttribute = meshPerAttribute || 1
  }

  InstancedInterleavedBuffer.prototype = Object.assign(Object.create(InterleavedBuffer.prototype), {
    constructor: InstancedInterleavedBuffer,
    isInstancedInterleavedBuffer: true,
    copy: function copy(source) {
      InterleavedBuffer.prototype.copy.call(this, source)
      this.meshPerAttribute = source.meshPerAttribute
      return this
    },
    clone: function clone(data) {
      var ib = InterleavedBuffer.prototype.clone.call(this, data)
      ib.meshPerAttribute = this.meshPerAttribute
      return ib
    },
    toJSON: function toJSON(data) {
      var json = InterleavedBuffer.prototype.toJSON.call(this, data)
      json.isInstancedInterleavedBuffer = true
      json.meshPerAttribute = this.meshPerAttribute
      return json
    }
  })

  function GLBufferAttribute(buffer, type, itemSize, elementSize, count) {
    this.buffer = buffer
    this.type = type
    this.itemSize = itemSize
    this.elementSize = elementSize
    this.count = count
    this.version = 0
  }

  Object.defineProperty(GLBufferAttribute.prototype, 'needsUpdate', {
    set: function set(value) {
      if (value === true) this.version++
    }
  })
  Object.assign(GLBufferAttribute.prototype, {
    isGLBufferAttribute: true,
    setBuffer: function setBuffer(buffer) {
      this.buffer = buffer
      return this
    },
    setType: function setType(type, elementSize) {
      this.type = type
      this.elementSize = elementSize
      return this
    },
    setItemSize: function setItemSize(itemSize) {
      this.itemSize = itemSize
      return this
    },
    setCount: function setCount(count) {
      this.count = count
      return this
    }
  })

  function Raycaster(origin, direction, near, far) {
    this.ray = new Ray(origin, direction) // direction is assumed to be normalized (for accurate distance calculations)

    this.near = near || 0
    this.far = far || Infinity
    this.camera = null
    this.layers = new Layers()
    this.params = {
      Mesh: {},
      Line: {
        threshold: 1
      },
      LOD: {},
      Points: {
        threshold: 1
      },
      Sprite: {}
    }
    Object.defineProperties(this.params, {
      PointCloud: {
        get: function get() {
          console.warn('THREE.Raycaster: params.PointCloud has been renamed to params.Points.')
          return this.Points
        }
      }
    })
  }

  function ascSort(a, b) {
    return a.distance - b.distance
  }

  function _intersectObject(object, raycaster, intersects, recursive) {
    if (object.layers.test(raycaster.layers)) {
      object.raycast(raycaster, intersects)
    }

    if (recursive === true) {
      var children = object.children

      for (var i = 0, l = children.length; i < l; i++) {
        _intersectObject(children[i], raycaster, intersects, true)
      }
    }
  }

  Object.assign(Raycaster.prototype, {
    set: function set(origin, direction) {
      // direction is assumed to be normalized (for accurate distance calculations)
      this.ray.set(origin, direction)
    },
    setFromCamera: function setFromCamera(coords, camera) {
      if (camera && 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 && 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.')
      }
    },
    intersectObject: function intersectObject(object, recursive, optionalTarget) {
      var intersects = optionalTarget || []

      _intersectObject(object, this, intersects, recursive)

      intersects.sort(ascSort)
      return intersects
    },
    intersectObjects: function intersectObjects(objects, recursive, optionalTarget) {
      var intersects = optionalTarget || []

      if (Array.isArray(objects) === false) {
        console.warn('THREE.Raycaster.intersectObjects: objects is not an Array.')
        return intersects
      }

      for (var i = 0, l = objects.length; i < l; i++) {
        _intersectObject(objects[i], this, intersects, recursive)
      }

      intersects.sort(ascSort)
      return intersects
    }
  })

  /**
   * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system
   *
   * The polar angle (phi) is measured from the positive y-axis. The positive y-axis is up.
   * The azimuthal angle (theta) is measured from the positive z-axis.
   */

  var Spherical = /*#__PURE__*/ (function () {
    function Spherical(radius, phi, theta) {
      if (radius === void 0) {
        radius = 1
      }

      if (phi === void 0) {
        phi = 0
      }

      if (theta === void 0) {
        theta = 0
      }

      this.radius = radius
      this.phi = phi // polar angle

      this.theta = theta // azimuthal angle

      return this
    }

    var _proto = Spherical.prototype

    _proto.set = function set(radius, phi, theta) {
      this.radius = radius
      this.phi = phi
      this.theta = theta
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(other) {
      this.radius = other.radius
      this.phi = other.phi
      this.theta = other.theta
      return this
    } // restrict phi to be betwee EPS and PI-EPS

    _proto.makeSafe = function makeSafe() {
      var EPS = 0.000001
      this.phi = Math.max(EPS, Math.min(Math.PI - EPS, this.phi))
      return this
    }

    _proto.setFromVector3 = function setFromVector3(v) {
      return this.setFromCartesianCoords(v.x, v.y, v.z)
    }

    _proto.setFromCartesianCoords = function 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(MathUtils.clamp(y / this.radius, -1, 1))
      }

      return this
    }

    return Spherical
  })()

  /**
   * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system
   */
  var Cylindrical = /*#__PURE__*/ (function () {
    function Cylindrical(radius, theta, y) {
      this.radius = radius !== undefined ? radius : 1.0 // distance from the origin to a point in the x-z plane

      this.theta = theta !== undefined ? theta : 0 // counterclockwise angle in the x-z plane measured in radians from the positive z-axis

      this.y = y !== undefined ? y : 0 // height above the x-z plane

      return this
    }

    var _proto = Cylindrical.prototype

    _proto.set = function set(radius, theta, y) {
      this.radius = radius
      this.theta = theta
      this.y = y
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(other) {
      this.radius = other.radius
      this.theta = other.theta
      this.y = other.y
      return this
    }

    _proto.setFromVector3 = function setFromVector3(v) {
      return this.setFromCartesianCoords(v.x, v.y, v.z)
    }

    _proto.setFromCartesianCoords = function setFromCartesianCoords(x, y, z) {
      this.radius = Math.sqrt(x * x + z * z)
      this.theta = Math.atan2(x, z)
      this.y = y
      return this
    }

    return Cylindrical
  })()

  var _vector$7 = /*@__PURE__*/ new Vector2()

  var Box2 = /*#__PURE__*/ (function () {
    function Box2(min, max) {
      Object.defineProperty(this, 'isBox2', {
        value: true
      })
      this.min = min !== undefined ? min : new Vector2(+Infinity, +Infinity)
      this.max = max !== undefined ? max : new Vector2(-Infinity, -Infinity)
    }

    var _proto = Box2.prototype

    _proto.set = function set(min, max) {
      this.min.copy(min)
      this.max.copy(max)
      return this
    }

    _proto.setFromPoints = function setFromPoints(points) {
      this.makeEmpty()

      for (var i = 0, il = points.length; i < il; i++) {
        this.expandByPoint(points[i])
      }

      return this
    }

    _proto.setFromCenterAndSize = function setFromCenterAndSize(center, size) {
      var halfSize = _vector$7.copy(size).multiplyScalar(0.5)

      this.min.copy(center).sub(halfSize)
      this.max.copy(center).add(halfSize)
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(box) {
      this.min.copy(box.min)
      this.max.copy(box.max)
      return this
    }

    _proto.makeEmpty = function makeEmpty() {
      this.min.x = this.min.y = +Infinity
      this.max.x = this.max.y = -Infinity
      return this
    }

    _proto.isEmpty = function 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
    }

    _proto.getCenter = function getCenter(target) {
      if (target === undefined) {
        console.warn('THREE.Box2: .getCenter() target is now required')
        target = new Vector2()
      }

      return this.isEmpty() ? target.set(0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5)
    }

    _proto.getSize = function getSize(target) {
      if (target === undefined) {
        console.warn('THREE.Box2: .getSize() target is now required')
        target = new Vector2()
      }

      return this.isEmpty() ? target.set(0, 0) : target.subVectors(this.max, this.min)
    }

    _proto.expandByPoint = function expandByPoint(point) {
      this.min.min(point)
      this.max.max(point)
      return this
    }

    _proto.expandByVector = function expandByVector(vector) {
      this.min.sub(vector)
      this.max.add(vector)
      return this
    }

    _proto.expandByScalar = function expandByScalar(scalar) {
      this.min.addScalar(-scalar)
      this.max.addScalar(scalar)
      return this
    }

    _proto.containsPoint = function containsPoint(point) {
      return point.x < this.min.x || point.x > this.max.x || point.y < this.min.y || point.y > this.max.y ? false : true
    }

    _proto.containsBox = function 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
    }

    _proto.getParameter = function getParameter(point, target) {
      // This can potentially have a divide by zero if the box
      // has a size dimension of 0.
      if (target === undefined) {
        console.warn('THREE.Box2: .getParameter() target is now required')
        target = new Vector2()
      }

      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))
    }

    _proto.intersectsBox = function 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 ? false : true
    }

    _proto.clampPoint = function clampPoint(point, target) {
      if (target === undefined) {
        console.warn('THREE.Box2: .clampPoint() target is now required')
        target = new Vector2()
      }

      return target.copy(point).clamp(this.min, this.max)
    }

    _proto.distanceToPoint = function distanceToPoint(point) {
      var clampedPoint = _vector$7.copy(point).clamp(this.min, this.max)

      return clampedPoint.sub(point).length()
    }

    _proto.intersect = function intersect(box) {
      this.min.max(box.min)
      this.max.min(box.max)
      return this
    }

    _proto.union = function union(box) {
      this.min.min(box.min)
      this.max.max(box.max)
      return this
    }

    _proto.translate = function translate(offset) {
      this.min.add(offset)
      this.max.add(offset)
      return this
    }

    _proto.equals = function equals(box) {
      return box.min.equals(this.min) && box.max.equals(this.max)
    }

    return Box2
  })()

  var _startP = /*@__PURE__*/ new Vector3()

  var _startEnd = /*@__PURE__*/ new Vector3()

  var Line3 = /*#__PURE__*/ (function () {
    function Line3(start, end) {
      this.start = start !== undefined ? start : new Vector3()
      this.end = end !== undefined ? end : new Vector3()
    }

    var _proto = Line3.prototype

    _proto.set = function set(start, end) {
      this.start.copy(start)
      this.end.copy(end)
      return this
    }

    _proto.clone = function clone() {
      return new this.constructor().copy(this)
    }

    _proto.copy = function copy(line) {
      this.start.copy(line.start)
      this.end.copy(line.end)
      return this
    }

    _proto.getCenter = function getCenter(target) {
      if (target === undefined) {
        console.warn('THREE.Line3: .getCenter() target is now required')
        target = new Vector3()
      }

      return target.addVectors(this.start, this.end).multiplyScalar(0.5)
    }

    _proto.delta = function delta(target) {
      if (target === undefined) {
        console.warn('THREE.Line3: .delta() target is now required')
        target = new Vector3()
      }

      return target.subVectors(this.end, this.start)
    }

    _proto.distanceSq = function distanceSq() {
      return this.start.distanceToSquared(this.end)
    }

    _proto.distance = function distance() {
      return this.start.distanceTo(this.end)
    }

    _proto.at = function at(t, target) {
      if (target === undefined) {
        console.warn('THREE.Line3: .at() target is now required')
        target = new Vector3()
      }

      return this.delta(target).multiplyScalar(t).add(this.start)
    }

    _proto.closestPointToPointParameter = function closestPointToPointParameter(point, clampToLine) {
      _startP.subVectors(point, this.start)

      _startEnd.subVectors(this.end, this.start)

      var startEnd2 = _startEnd.dot(_startEnd)

      var startEnd_startP = _startEnd.dot(_startP)

      var t = startEnd_startP / startEnd2

      if (clampToLine) {
        t = MathUtils.clamp(t, 0, 1)
      }

      return t
    }

    _proto.closestPointToPoint = function closestPointToPoint(point, clampToLine, target) {
      var t = this.closestPointToPointParameter(point, clampToLine)

      if (target === undefined) {
        console.warn('THREE.Line3: .closestPointToPoint() target is now required')
        target = new Vector3()
      }

      return this.delta(target).multiplyScalar(t).add(this.start)
    }

    _proto.applyMatrix4 = function applyMatrix4(matrix) {
      this.start.applyMatrix4(matrix)
      this.end.applyMatrix4(matrix)
      return this
    }

    _proto.equals = function equals(line) {
      return line.start.equals(this.start) && line.end.equals(this.end)
    }

    return Line3
  })()

  function ImmediateRenderObject(material) {
    Object3D.call(this)
    this.material = material

    this.render = function () /* renderCallback */
    {}

    this.hasPositions = false
    this.hasNormals = false
    this.hasColors = false
    this.hasUvs = false
    this.positionArray = null
    this.normalArray = null
    this.colorArray = null
    this.uvArray = null
    this.count = 0
  }

  ImmediateRenderObject.prototype = Object.create(Object3D.prototype)
  ImmediateRenderObject.prototype.constructor = ImmediateRenderObject
  ImmediateRenderObject.prototype.isImmediateRenderObject = true

  var _vector$8 = /*@__PURE__*/ new Vector3()

  var SpotLightHelper = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(SpotLightHelper, _Object3D)

    function SpotLightHelper(light, color) {
      var _this

      _this = _Object3D.call(this) || this
      _this.light = light

      _this.light.updateMatrixWorld()

      _this.matrix = light.matrixWorld
      _this.matrixAutoUpdate = false
      _this.color = color
      var geometry = new BufferGeometry()
      var 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 (var i = 0, j = 1, l = 32; i < l; i++, j++) {
        var p1 = (i / l) * Math.PI * 2
        var 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 Float32BufferAttribute(positions, 3))
      var material = new LineBasicMaterial({
        fog: false,
        toneMapped: false
      })
      _this.cone = new LineSegments(geometry, material)

      _this.add(_this.cone)

      _this.update()

      return _this
    }

    var _proto = SpotLightHelper.prototype

    _proto.dispose = function dispose() {
      this.cone.geometry.dispose()
      this.cone.material.dispose()
    }

    _proto.update = function update() {
      this.light.updateMatrixWorld()
      var coneLength = this.light.distance ? this.light.distance : 1000
      var coneWidth = coneLength * Math.tan(this.light.angle)
      this.cone.scale.set(coneWidth, coneWidth, coneLength)

      _vector$8.setFromMatrixPosition(this.light.target.matrixWorld)

      this.cone.lookAt(_vector$8)

      if (this.color !== undefined) {
        this.cone.material.color.set(this.color)
      } else {
        this.cone.material.color.copy(this.light.color)
      }
    }

    return SpotLightHelper
  })(Object3D)

  var _vector$9 = /*@__PURE__*/ new Vector3()

  var _boneMatrix = /*@__PURE__*/ new Matrix4()

  var _matrixWorldInv = /*@__PURE__*/ new Matrix4()

  var SkeletonHelper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(SkeletonHelper, _LineSegments)

    function SkeletonHelper(object) {
      var _this

      var bones = getBoneList(object)
      var geometry = new BufferGeometry()
      var vertices = []
      var colors = []
      var color1 = new Color(0, 0, 1)
      var color2 = new Color(0, 1, 0)

      for (var i = 0; i < bones.length; i++) {
        var 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 Float32BufferAttribute(vertices, 3))
      geometry.setAttribute('color', new Float32BufferAttribute(colors, 3))
      var material = new LineBasicMaterial({
        vertexColors: true,
        depthTest: false,
        depthWrite: false,
        toneMapped: false,
        transparent: true
      })
      _this = _LineSegments.call(this, geometry, material) || this
      _this.type = 'SkeletonHelper'
      _this.isSkeletonHelper = true
      _this.root = object
      _this.bones = bones
      _this.matrix = object.matrixWorld
      _this.matrixAutoUpdate = false
      return _this
    }

    var _proto = SkeletonHelper.prototype

    _proto.updateMatrixWorld = function updateMatrixWorld(force) {
      var bones = this.bones
      var geometry = this.geometry
      var position = geometry.getAttribute('position')

      _matrixWorldInv.copy(this.root.matrixWorld).invert()

      for (var i = 0, j = 0; i < bones.length; i++) {
        var bone = bones[i]

        if (bone.parent && bone.parent.isBone) {
          _boneMatrix.multiplyMatrices(_matrixWorldInv, bone.matrixWorld)

          _vector$9.setFromMatrixPosition(_boneMatrix)

          position.setXYZ(j, _vector$9.x, _vector$9.y, _vector$9.z)

          _boneMatrix.multiplyMatrices(_matrixWorldInv, bone.parent.matrixWorld)

          _vector$9.setFromMatrixPosition(_boneMatrix)

          position.setXYZ(j + 1, _vector$9.x, _vector$9.y, _vector$9.z)
          j += 2
        }
      }

      geometry.getAttribute('position').needsUpdate = true

      _LineSegments.prototype.updateMatrixWorld.call(this, force)
    }

    return SkeletonHelper
  })(LineSegments)

  function getBoneList(object) {
    var boneList = []

    if (object && object.isBone) {
      boneList.push(object)
    }

    for (var i = 0; i < object.children.length; i++) {
      boneList.push.apply(boneList, getBoneList(object.children[i]))
    }

    return boneList
  }

  var PointLightHelper = /*#__PURE__*/ (function (_Mesh) {
    _inheritsLoose(PointLightHelper, _Mesh)

    function PointLightHelper(light, sphereSize, color) {
      var _this

      var geometry = new SphereBufferGeometry(sphereSize, 4, 2)
      var material = new MeshBasicMaterial({
        wireframe: true,
        fog: false,
        toneMapped: false
      })
      _this = _Mesh.call(this, geometry, material) || this
      _this.light = light

      _this.light.updateMatrixWorld()

      _this.color = color
      _this.type = 'PointLightHelper'
      _this.matrix = _this.light.matrixWorld
      _this.matrixAutoUpdate = false

      _this.update()
      /*
			// TODO: delete this comment?
			const distanceGeometry = new THREE.IcosahedronBufferGeometry( 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 );
			*/

      return _this
    }

    var _proto = PointLightHelper.prototype

    _proto.dispose = function dispose() {
      this.geometry.dispose()
      this.material.dispose()
    }

    _proto.update = function update() {
      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 );
				}
			*/
    }

    return PointLightHelper
  })(Mesh)

  var _vector$a = /*@__PURE__*/ new Vector3()

  var _color1 = /*@__PURE__*/ new Color()

  var _color2 = /*@__PURE__*/ new Color()

  var HemisphereLightHelper = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(HemisphereLightHelper, _Object3D)

    function HemisphereLightHelper(light, size, color) {
      var _this

      _this = _Object3D.call(this) || this
      _this.light = light

      _this.light.updateMatrixWorld()

      _this.matrix = light.matrixWorld
      _this.matrixAutoUpdate = false
      _this.color = color
      var geometry = new OctahedronBufferGeometry(size)
      geometry.rotateY(Math.PI * 0.5)
      _this.material = new MeshBasicMaterial({
        wireframe: true,
        fog: false,
        toneMapped: false
      })
      if (_this.color === undefined) _this.material.vertexColors = true
      var position = geometry.getAttribute('position')
      var colors = new Float32Array(position.count * 3)
      geometry.setAttribute('color', new BufferAttribute(colors, 3))

      _this.add(new Mesh(geometry, _this.material))

      _this.update()

      return _this
    }

    var _proto = HemisphereLightHelper.prototype

    _proto.dispose = function dispose() {
      this.children[0].geometry.dispose()
      this.children[0].material.dispose()
    }

    _proto.update = function update() {
      var mesh = this.children[0]

      if (this.color !== undefined) {
        this.material.color.set(this.color)
      } else {
        var colors = mesh.geometry.getAttribute('color')

        _color1.copy(this.light.color)

        _color2.copy(this.light.groundColor)

        for (var i = 0, l = colors.count; i < l; i++) {
          var color = i < l / 2 ? _color1 : _color2
          colors.setXYZ(i, color.r, color.g, color.b)
        }

        colors.needsUpdate = true
      }

      mesh.lookAt(_vector$a.setFromMatrixPosition(this.light.matrixWorld).negate())
    }

    return HemisphereLightHelper
  })(Object3D)

  var GridHelper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(GridHelper, _LineSegments)

    function GridHelper(size, divisions, color1, color2) {
      var _this

      if (size === void 0) {
        size = 10
      }

      if (divisions === void 0) {
        divisions = 10
      }

      if (color1 === void 0) {
        color1 = 0x444444
      }

      if (color2 === void 0) {
        color2 = 0x888888
      }

      color1 = new Color(color1)
      color2 = new Color(color2)
      var center = divisions / 2
      var step = size / divisions
      var halfSize = size / 2
      var vertices = [],
        colors = []

      for (var 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)
        var 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
      }

      var geometry = new BufferGeometry()
      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
      geometry.setAttribute('color', new Float32BufferAttribute(colors, 3))
      var material = new LineBasicMaterial({
        vertexColors: true,
        toneMapped: false
      })
      _this = _LineSegments.call(this, geometry, material) || this
      _this.type = 'GridHelper'
      return _this
    }

    return GridHelper
  })(LineSegments)

  var PolarGridHelper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(PolarGridHelper, _LineSegments)

    function PolarGridHelper(radius, radials, circles, divisions, color1, color2) {
      var _this

      if (radius === void 0) {
        radius = 10
      }

      if (radials === void 0) {
        radials = 16
      }

      if (circles === void 0) {
        circles = 8
      }

      if (divisions === void 0) {
        divisions = 64
      }

      if (color1 === void 0) {
        color1 = 0x444444
      }

      if (color2 === void 0) {
        color2 = 0x888888
      }

      color1 = new Color(color1)
      color2 = new Color(color2)
      var vertices = []
      var colors = [] // create the radials

      for (var i = 0; i <= radials; i++) {
        var v = (i / radials) * (Math.PI * 2)
        var x = Math.sin(v) * radius
        var z = Math.cos(v) * radius
        vertices.push(0, 0, 0)
        vertices.push(x, 0, z)
        var color = i & 1 ? color1 : color2
        colors.push(color.r, color.g, color.b)
        colors.push(color.r, color.g, color.b)
      } // create the circles

      for (var _i = 0; _i <= circles; _i++) {
        var _color = _i & 1 ? color1 : color2

        var r = radius - (radius / circles) * _i

        for (var j = 0; j < divisions; j++) {
          // first vertex
          var _v = (j / divisions) * (Math.PI * 2)

          var _x = Math.sin(_v) * r

          var _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)
        }
      }

      var geometry = new BufferGeometry()
      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
      geometry.setAttribute('color', new Float32BufferAttribute(colors, 3))
      var material = new LineBasicMaterial({
        vertexColors: true,
        toneMapped: false
      })
      _this = _LineSegments.call(this, geometry, material) || this
      _this.type = 'PolarGridHelper'
      return _this
    }

    return PolarGridHelper
  })(LineSegments)

  var _v1$6 = /*@__PURE__*/ new Vector3()

  var _v2$3 = /*@__PURE__*/ new Vector3()

  var _v3$1 = /*@__PURE__*/ new Vector3()

  var DirectionalLightHelper = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(DirectionalLightHelper, _Object3D)

    function DirectionalLightHelper(light, size, color) {
      var _this

      _this = _Object3D.call(this) || this
      _this.light = light

      _this.light.updateMatrixWorld()

      _this.matrix = light.matrixWorld
      _this.matrixAutoUpdate = false
      _this.color = color
      if (size === undefined) size = 1
      var geometry = new BufferGeometry()
      geometry.setAttribute('position', new Float32BufferAttribute([-size, size, 0, size, size, 0, size, -size, 0, -size, -size, 0, -size, size, 0], 3))
      var material = new LineBasicMaterial({
        fog: false,
        toneMapped: false
      })
      _this.lightPlane = new Line(geometry, material)

      _this.add(_this.lightPlane)

      geometry = new BufferGeometry()
      geometry.setAttribute('position', new Float32BufferAttribute([0, 0, 0, 0, 0, 1], 3))
      _this.targetLine = new Line(geometry, material)

      _this.add(_this.targetLine)

      _this.update()

      return _this
    }

    var _proto = DirectionalLightHelper.prototype

    _proto.dispose = function dispose() {
      this.lightPlane.geometry.dispose()
      this.lightPlane.material.dispose()
      this.targetLine.geometry.dispose()
      this.targetLine.material.dispose()
    }

    _proto.update = function update() {
      _v1$6.setFromMatrixPosition(this.light.matrixWorld)

      _v2$3.setFromMatrixPosition(this.light.target.matrixWorld)

      _v3$1.subVectors(_v2$3, _v1$6)

      this.lightPlane.lookAt(_v2$3)

      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(_v2$3)
      this.targetLine.scale.z = _v3$1.length()
    }

    return DirectionalLightHelper
  })(Object3D)

  var _vector$b = /*@__PURE__*/ new Vector3()

  var _camera = /*@__PURE__*/ new Camera()
  /**
   *	- shows frustum, line of sight and up of the camera
   *	- suitable for fast updates
   * 	- based on frustum visualization in lightgl.js shadowmap example
   *		http://evanw.github.com/lightgl.js/tests/shadowmap.html
   */

  var CameraHelper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(CameraHelper, _LineSegments)

    function CameraHelper(camera) {
      var _this

      var geometry = new BufferGeometry()
      var material = new LineBasicMaterial({
        color: 0xffffff,
        vertexColors: true,
        toneMapped: false
      })
      var vertices = []
      var colors = []
      var pointMap = {} // colors

      var colorFrustum = new Color(0xffaa00)
      var colorCone = new Color(0xff0000)
      var colorUp = new Color(0x00aaff)
      var colorTarget = new Color(0xffffff)
      var colorCross = new Color(0x333333) // near

      addLine('n1', 'n2', colorFrustum)
      addLine('n2', 'n4', colorFrustum)
      addLine('n4', 'n3', colorFrustum)
      addLine('n3', 'n1', colorFrustum) // far

      addLine('f1', 'f2', colorFrustum)
      addLine('f2', 'f4', colorFrustum)
      addLine('f4', 'f3', colorFrustum)
      addLine('f3', 'f1', colorFrustum) // sides

      addLine('n1', 'f1', colorFrustum)
      addLine('n2', 'f2', colorFrustum)
      addLine('n3', 'f3', colorFrustum)
      addLine('n4', 'f4', colorFrustum) // cone

      addLine('p', 'n1', colorCone)
      addLine('p', 'n2', colorCone)
      addLine('p', 'n3', colorCone)
      addLine('p', 'n4', colorCone) // up

      addLine('u1', 'u2', colorUp)
      addLine('u2', 'u3', colorUp)
      addLine('u3', 'u1', colorUp) // target

      addLine('c', 't', colorTarget)
      addLine('p', 'c', colorCross) // cross

      addLine('cn1', 'cn2', colorCross)
      addLine('cn3', 'cn4', colorCross)
      addLine('cf1', 'cf2', colorCross)
      addLine('cf3', 'cf4', colorCross)

      function addLine(a, b, color) {
        addPoint(a, color)
        addPoint(b, color)
      }

      function addPoint(id, color) {
        vertices.push(0, 0, 0)
        colors.push(color.r, color.g, color.b)

        if (pointMap[id] === undefined) {
          pointMap[id] = []
        }

        pointMap[id].push(vertices.length / 3 - 1)
      }

      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
      geometry.setAttribute('color', new Float32BufferAttribute(colors, 3))
      _this = _LineSegments.call(this, geometry, material) || this
      _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()

      return _this
    }

    var _proto = CameraHelper.prototype

    _proto.update = function update() {
      var geometry = this.geometry
      var pointMap = this.pointMap
      var w = 1,
        h = 1 // we need just camera projection matrix inverse
      // world matrix must be identity

      _camera.projectionMatrixInverse.copy(this.camera.projectionMatrixInverse) // center / target

      setPoint('c', pointMap, geometry, _camera, 0, 0, -1)
      setPoint('t', pointMap, geometry, _camera, 0, 0, 1) // near

      setPoint('n1', pointMap, geometry, _camera, -w, -h, -1)
      setPoint('n2', pointMap, geometry, _camera, w, -h, -1)
      setPoint('n3', pointMap, geometry, _camera, -w, h, -1)
      setPoint('n4', pointMap, geometry, _camera, w, h, -1) // far

      setPoint('f1', pointMap, geometry, _camera, -w, -h, 1)
      setPoint('f2', pointMap, geometry, _camera, w, -h, 1)
      setPoint('f3', pointMap, geometry, _camera, -w, h, 1)
      setPoint('f4', pointMap, geometry, _camera, w, h, 1) // up

      setPoint('u1', pointMap, geometry, _camera, w * 0.7, h * 1.1, -1)
      setPoint('u2', pointMap, geometry, _camera, -w * 0.7, h * 1.1, -1)
      setPoint('u3', pointMap, geometry, _camera, 0, h * 2, -1) // cross

      setPoint('cf1', pointMap, geometry, _camera, -w, 0, 1)
      setPoint('cf2', pointMap, geometry, _camera, w, 0, 1)
      setPoint('cf3', pointMap, geometry, _camera, 0, -h, 1)
      setPoint('cf4', pointMap, geometry, _camera, 0, h, 1)
      setPoint('cn1', pointMap, geometry, _camera, -w, 0, -1)
      setPoint('cn2', pointMap, geometry, _camera, w, 0, -1)
      setPoint('cn3', pointMap, geometry, _camera, 0, -h, -1)
      setPoint('cn4', pointMap, geometry, _camera, 0, h, -1)
      geometry.getAttribute('position').needsUpdate = true
    }

    return CameraHelper
  })(LineSegments)

  function setPoint(point, pointMap, geometry, camera, x, y, z) {
    _vector$b.set(x, y, z).unproject(camera)

    var points = pointMap[point]

    if (points !== undefined) {
      var position = geometry.getAttribute('position')

      for (var i = 0, l = points.length; i < l; i++) {
        position.setXYZ(points[i], _vector$b.x, _vector$b.y, _vector$b.z)
      }
    }
  }

  var _box$3 = /*@__PURE__*/ new Box3()

  var BoxHelper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(BoxHelper, _LineSegments)

    function BoxHelper(object, color) {
      var _this

      if (color === void 0) {
        color = 0xffff00
      }

      var 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])
      var positions = new Float32Array(8 * 3)
      var geometry = new BufferGeometry()
      geometry.setIndex(new BufferAttribute(indices, 1))
      geometry.setAttribute('position', new BufferAttribute(positions, 3))
      _this =
        _LineSegments.call(
          this,
          geometry,
          new LineBasicMaterial({
            color: color,
            toneMapped: false
          })
        ) || this
      _this.object = object
      _this.type = 'BoxHelper'
      _this.matrixAutoUpdate = false

      _this.update()

      return _this
    }

    var _proto = BoxHelper.prototype

    _proto.update = function update(object) {
      if (object !== undefined) {
        console.warn('THREE.BoxHelper: .update() has no longer arguments.')
      }

      if (this.object !== undefined) {
        _box$3.setFromObject(this.object)
      }

      if (_box$3.isEmpty()) return
      var min = _box$3.min
      var max = _box$3.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
			*/

      var position = this.geometry.attributes.position
      var 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()
    }

    _proto.setFromObject = function setFromObject(object) {
      this.object = object
      this.update()
      return this
    }

    _proto.copy = function copy(source) {
      LineSegments.prototype.copy.call(this, source)
      this.object = source.object
      return this
    }

    return BoxHelper
  })(LineSegments)

  var Box3Helper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(Box3Helper, _LineSegments)

    function Box3Helper(box, color) {
      var _this

      if (color === void 0) {
        color = 0xffff00
      }

      var 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])
      var 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]
      var geometry = new BufferGeometry()
      geometry.setIndex(new BufferAttribute(indices, 1))
      geometry.setAttribute('position', new Float32BufferAttribute(positions, 3))
      _this =
        _LineSegments.call(
          this,
          geometry,
          new LineBasicMaterial({
            color: color,
            toneMapped: false
          })
        ) || this
      _this.box = box
      _this.type = 'Box3Helper'

      _this.geometry.computeBoundingSphere()

      return _this
    }

    var _proto = Box3Helper.prototype

    _proto.updateMatrixWorld = function updateMatrixWorld(force) {
      var box = this.box
      if (box.isEmpty()) return
      box.getCenter(this.position)
      box.getSize(this.scale)
      this.scale.multiplyScalar(0.5)

      _LineSegments.prototype.updateMatrixWorld.call(this, force)
    }

    return Box3Helper
  })(LineSegments)

  var PlaneHelper = /*#__PURE__*/ (function (_Line) {
    _inheritsLoose(PlaneHelper, _Line)

    function PlaneHelper(plane, size, hex) {
      var _this

      if (size === void 0) {
        size = 1
      }

      if (hex === void 0) {
        hex = 0xffff00
      }

      var color = hex
      var 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, 0, 0, 1, 0, 0, 0]
      var geometry = new BufferGeometry()
      geometry.setAttribute('position', new Float32BufferAttribute(positions, 3))
      geometry.computeBoundingSphere()
      _this =
        _Line.call(
          this,
          geometry,
          new LineBasicMaterial({
            color: color,
            toneMapped: false
          })
        ) || this
      _this.type = 'PlaneHelper'
      _this.plane = plane
      _this.size = size
      var positions2 = [1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, -1, 1]
      var geometry2 = new BufferGeometry()
      geometry2.setAttribute('position', new Float32BufferAttribute(positions2, 3))
      geometry2.computeBoundingSphere()

      _this.add(
        new Mesh(
          geometry2,
          new MeshBasicMaterial({
            color: color,
            opacity: 0.2,
            transparent: true,
            depthWrite: false,
            toneMapped: false
          })
        )
      )

      return _this
    }

    var _proto = PlaneHelper.prototype

    _proto.updateMatrixWorld = function updateMatrixWorld(force) {
      var scale = -this.plane.constant
      if (Math.abs(scale) < 1e-8) scale = 1e-8 // sign does not matter

      this.scale.set(0.5 * this.size, 0.5 * this.size, scale)
      this.children[0].material.side = scale < 0 ? BackSide : FrontSide // renderer flips side when determinant < 0; flipping not wanted here

      this.lookAt(this.plane.normal)

      _Line.prototype.updateMatrixWorld.call(this, force)
    }

    return PlaneHelper
  })(Line)

  var _axis = /*@__PURE__*/ new Vector3()

  var _lineGeometry, _coneGeometry

  var ArrowHelper = /*#__PURE__*/ (function (_Object3D) {
    _inheritsLoose(ArrowHelper, _Object3D)

    function ArrowHelper(dir, origin, length, color, headLength, headWidth) {
      var _this

      _this = _Object3D.call(this) || this // dir is assumed to be normalized

      _this.type = 'ArrowHelper'
      if (dir === undefined) dir = new Vector3(0, 0, 1)
      if (origin === undefined) origin = new Vector3(0, 0, 0)
      if (length === undefined) length = 1
      if (color === undefined) color = 0xffff00
      if (headLength === undefined) headLength = 0.2 * length
      if (headWidth === undefined) headWidth = 0.2 * headLength

      if (_lineGeometry === undefined) {
        _lineGeometry = new BufferGeometry()

        _lineGeometry.setAttribute('position', new Float32BufferAttribute([0, 0, 0, 0, 1, 0], 3))

        _coneGeometry = new CylinderBufferGeometry(0, 0.5, 1, 5, 1)

        _coneGeometry.translate(0, -0.5, 0)
      }

      _this.position.copy(origin)

      _this.line = new Line(
        _lineGeometry,
        new LineBasicMaterial({
          color: color,
          toneMapped: false
        })
      )
      _this.line.matrixAutoUpdate = false

      _this.add(_this.line)

      _this.cone = new Mesh(
        _coneGeometry,
        new MeshBasicMaterial({
          color: color,
          toneMapped: false
        })
      )
      _this.cone.matrixAutoUpdate = false

      _this.add(_this.cone)

      _this.setDirection(dir)

      _this.setLength(length, headLength, headWidth)

      return _this
    }

    var _proto = ArrowHelper.prototype

    _proto.setDirection = function 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 {
        _axis.set(dir.z, 0, -dir.x).normalize()

        var radians = Math.acos(dir.y)
        this.quaternion.setFromAxisAngle(_axis, radians)
      }
    }

    _proto.setLength = function setLength(length, headLength, headWidth) {
      if (headLength === undefined) headLength = 0.2 * length
      if (headWidth === undefined) headWidth = 0.2 * headLength
      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()
    }

    _proto.setColor = function setColor(color) {
      this.line.material.color.set(color)
      this.cone.material.color.set(color)
    }

    _proto.copy = function copy(source) {
      _Object3D.prototype.copy.call(this, source, false)

      this.line.copy(source.line)
      this.cone.copy(source.cone)
      return this
    }

    return ArrowHelper
  })(Object3D)

  var AxesHelper = /*#__PURE__*/ (function (_LineSegments) {
    _inheritsLoose(AxesHelper, _LineSegments)

    function AxesHelper(size) {
      var _this

      if (size === void 0) {
        size = 1
      }

      var vertices = [0, 0, 0, size, 0, 0, 0, 0, 0, 0, size, 0, 0, 0, 0, 0, 0, size]
      var colors = [1, 0, 0, 1, 0.6, 0, 0, 1, 0, 0.6, 1, 0, 0, 0, 1, 0, 0.6, 1]
      var geometry = new BufferGeometry()
      geometry.setAttribute('position', new Float32BufferAttribute(vertices, 3))
      geometry.setAttribute('color', new Float32BufferAttribute(colors, 3))
      var material = new LineBasicMaterial({
        vertexColors: true,
        toneMapped: false
      })
      _this = _LineSegments.call(this, geometry, material) || this
      _this.type = 'AxesHelper'
      return _this
    }

    return AxesHelper
  })(LineSegments)

  var _floatView = new Float32Array(1)

  var _int32View = new Int32Array(_floatView.buffer)

  var DataUtils = {
    // Converts float32 to float16 (stored as uint16 value).
    toHalfFloat: function toHalfFloat(val) {
      // Source: http://gamedev.stackexchange.com/questions/17326/conversion-of-a-number-from-single-precision-floating-point-representation-to-a/17410#17410

      /* This method is faster than the OpenEXR implementation (very often
       * used, eg. in Ogre), with the additional benefit of rounding, inspired
       * by James Tursa?s half-precision code. */
      _floatView[0] = val
      var x = _int32View[0]
      var bits = (x >> 16) & 0x8000
      /* Get the sign */

      var m = (x >> 12) & 0x07ff
      /* Keep one extra bit for rounding */

      var e = (x >> 23) & 0xff
      /* Using int is faster here */

      /* If zero, or denormal, or exponent underflows too much for a denormal
       * half, return signed zero. */

      if (e < 103) return bits
      /* If NaN, return NaN. If Inf or exponent overflow, return Inf. */

      if (e > 142) {
        bits |= 0x7c00
        /* If exponent was 0xff and one mantissa bit was set, it means NaN,
         * not Inf, so make sure we set one mantissa bit too. */

        bits |= (e == 255 ? 0 : 1) && x & 0x007fffff
        return bits
      }
      /* If exponent underflows but not too much, return a denormal */

      if (e < 113) {
        m |= 0x0800
        /* Extra rounding may overflow and set mantissa to 0 and exponent
         * to 1, which is OK. */

        bits |= (m >> (114 - e)) + ((m >> (113 - e)) & 1)
        return bits
      }

      bits |= ((e - 112) << 10) | (m >> 1)
      /* Extra rounding. An overflow will set mantissa to 0 and increment
       * the exponent, which is OK. */

      bits += m & 1
      return bits
    }
  }

  var _ENCODINGS
  var LOD_MIN = 4
  var LOD_MAX = 8
  var SIZE_MAX = Math.pow(2, LOD_MAX) // 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.

  var EXTRA_LOD_SIGMA = [0.125, 0.215, 0.35, 0.446, 0.526, 0.582]
  var TOTAL_LODS = LOD_MAX - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length // The maximum length of the blur for loop. Smaller sigmas will use fewer
  // samples and exit early, but not recompile the shader.

  var MAX_SAMPLES = 20
  var ENCODINGS =
    ((_ENCODINGS = {}),
    (_ENCODINGS[LinearEncoding] = 0),
    (_ENCODINGS[sRGBEncoding] = 1),
    (_ENCODINGS[RGBEEncoding] = 2),
    (_ENCODINGS[RGBM7Encoding] = 3),
    (_ENCODINGS[RGBM16Encoding] = 4),
    (_ENCODINGS[RGBDEncoding] = 5),
    (_ENCODINGS[GammaEncoding] = 6),
    _ENCODINGS)

  var _flatCamera = /*@__PURE__*/ new OrthographicCamera()

  var _createPlanes2 = /*@__PURE__*/ _createPlanes(),
    _lodPlanes = _createPlanes2._lodPlanes,
    _sizeLods = _createPlanes2._sizeLods,
    _sigmas = _createPlanes2._sigmas

  var _clearColor = /*@__PURE__*/ new Color()

  var _oldTarget = null // Golden Ratio

  var PHI = (1 + Math.sqrt(5)) / 2
  var INV_PHI = 1 / PHI // Vertices of a dodecahedron (except the opposites, which represent the
  // same axis), used as axis directions evenly spread on a sphere.

  var _axisDirections = [
    /*@__PURE__*/ new Vector3(1, 1, 1),
    /*@__PURE__*/ new Vector3(-1, 1, 1),
    /*@__PURE__*/ new Vector3(1, 1, -1),
    /*@__PURE__*/ new Vector3(-1, 1, -1),
    /*@__PURE__*/ new Vector3(0, PHI, INV_PHI),
    /*@__PURE__*/ new Vector3(0, PHI, -INV_PHI),
    /*@__PURE__*/ new Vector3(INV_PHI, 0, PHI),
    /*@__PURE__*/ new Vector3(-INV_PHI, 0, PHI),
    /*@__PURE__*/ new Vector3(PHI, INV_PHI, 0),
    /*@__PURE__*/ new Vector3(-PHI, INV_PHI, 0)
  ]
  /**
   * 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.
   */

  var PMREMGenerator = /*#__PURE__*/ (function () {
    function PMREMGenerator(renderer) {
      this._renderer = renderer
      this._pingPongRenderTarget = null
      this._blurMaterial = _getBlurShader(MAX_SAMPLES)
      this._equirectShader = null
      this._cubemapShader = 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).
     */

    var _proto = PMREMGenerator.prototype

    _proto.fromScene = function fromScene(scene, sigma, near, far) {
      if (sigma === void 0) {
        sigma = 0
      }

      if (near === void 0) {
        near = 0.1
      }

      if (far === void 0) {
        far = 100
      }

      _oldTarget = this._renderer.getRenderTarget()

      var cubeUVRenderTarget = this._allocateTargets()

      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
     * (RGBFormat) or HDR (RGBEFormat). The ideal input image size is 1k (1024 x 512),
     * as this matches best with the 256 x 256 cubemap output.
     */

    _proto.fromEquirectangular = function fromEquirectangular(equirectangular) {
      return this._fromTexture(equirectangular)
    }
    /**
     * Generates a PMREM from an cubemap texture, which can be either LDR
     * (RGBFormat) or HDR (RGBEFormat). The ideal input cube size is 256 x 256,
     * as this matches best with the 256 x 256 cubemap output.
     */

    _proto.fromCubemap = function fromCubemap(cubemap) {
      return this._fromTexture(cubemap)
    }
    /**
     * Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during
     * your texture's network fetch for increased concurrency.
     */

    _proto.compileCubemapShader = function compileCubemapShader() {
      if (this._cubemapShader === null) {
        this._cubemapShader = _getCubemapShader()

        this._compileMaterial(this._cubemapShader)
      }
    }
    /**
     * Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during
     * your texture's network fetch for increased concurrency.
     */

    _proto.compileEquirectangularShader = function compileEquirectangularShader() {
      if (this._equirectShader === null) {
        this._equirectShader = _getEquirectShader()

        this._compileMaterial(this._equirectShader)
      }
    }
    /**
     * 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.
     */

    _proto.dispose = function dispose() {
      this._blurMaterial.dispose()

      if (this._cubemapShader !== null) this._cubemapShader.dispose()
      if (this._equirectShader !== null) this._equirectShader.dispose()

      for (var i = 0; i < _lodPlanes.length; i++) {
        _lodPlanes[i].dispose()
      }
    } // private interface

    _proto._cleanup = function _cleanup(outputTarget) {
      this._pingPongRenderTarget.dispose()

      this._renderer.setRenderTarget(_oldTarget)

      outputTarget.scissorTest = false

      _setViewport(outputTarget, 0, 0, outputTarget.width, outputTarget.height)
    }

    _proto._fromTexture = function _fromTexture(texture) {
      _oldTarget = this._renderer.getRenderTarget()

      var cubeUVRenderTarget = this._allocateTargets(texture)

      this._textureToCubeUV(texture, cubeUVRenderTarget)

      this._applyPMREM(cubeUVRenderTarget)

      this._cleanup(cubeUVRenderTarget)

      return cubeUVRenderTarget
    }

    _proto._allocateTargets = function _allocateTargets(texture) {
      // warning: null texture is valid
      var params = {
        magFilter: NearestFilter,
        minFilter: NearestFilter,
        generateMipmaps: false,
        type: UnsignedByteType,
        format: RGBEFormat,
        encoding: _isLDR(texture) ? texture.encoding : RGBEEncoding,
        depthBuffer: false
      }

      var cubeUVRenderTarget = _createRenderTarget(params)

      cubeUVRenderTarget.depthBuffer = texture ? false : true
      this._pingPongRenderTarget = _createRenderTarget(params)
      return cubeUVRenderTarget
    }

    _proto._compileMaterial = function _compileMaterial(material) {
      var tmpMesh = new Mesh(_lodPlanes[0], material)

      this._renderer.compile(tmpMesh, _flatCamera)
    }

    _proto._sceneToCubeUV = function _sceneToCubeUV(scene, near, far, cubeUVRenderTarget) {
      var fov = 90
      var aspect = 1
      var cubeCamera = new PerspectiveCamera(fov, aspect, near, far)
      var upSign = [1, -1, 1, 1, 1, 1]
      var forwardSign = [1, 1, 1, -1, -1, -1]
      var renderer = this._renderer
      var outputEncoding = renderer.outputEncoding
      var toneMapping = renderer.toneMapping
      renderer.getClearColor(_clearColor)
      var clearAlpha = renderer.getClearAlpha()
      renderer.toneMapping = NoToneMapping
      renderer.outputEncoding = LinearEncoding
      var background = scene.background

      if (background && background.isColor) {
        background.convertSRGBToLinear() // Convert linear to RGBE

        var maxComponent = Math.max(background.r, background.g, background.b)
        var fExp = Math.min(Math.max(Math.ceil(Math.log2(maxComponent)), -128.0), 127.0)
        background = background.multiplyScalar(Math.pow(2.0, -fExp))
        var alpha = (fExp + 128.0) / 255.0
        renderer.setClearColor(background, alpha)
        scene.background = null
      }

      for (var i = 0; i < 6; i++) {
        var 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])
        }

        _setViewport(cubeUVRenderTarget, col * SIZE_MAX, i > 2 ? SIZE_MAX : 0, SIZE_MAX, SIZE_MAX)

        renderer.setRenderTarget(cubeUVRenderTarget)
        renderer.render(scene, cubeCamera)
      }

      renderer.toneMapping = toneMapping
      renderer.outputEncoding = outputEncoding
      renderer.setClearColor(_clearColor, clearAlpha)
    }

    _proto._textureToCubeUV = function _textureToCubeUV(texture, cubeUVRenderTarget) {
      var renderer = this._renderer

      if (texture.isCubeTexture) {
        if (this._cubemapShader == null) {
          this._cubemapShader = _getCubemapShader()
        }
      } else {
        if (this._equirectShader == null) {
          this._equirectShader = _getEquirectShader()
        }
      }

      var material = texture.isCubeTexture ? this._cubemapShader : this._equirectShader
      var mesh = new Mesh(_lodPlanes[0], material)
      var uniforms = material.uniforms
      uniforms['envMap'].value = texture

      if (!texture.isCubeTexture) {
        uniforms['texelSize'].value.set(1.0 / texture.image.width, 1.0 / texture.image.height)
      }

      uniforms['inputEncoding'].value = ENCODINGS[texture.encoding]
      uniforms['outputEncoding'].value = ENCODINGS[cubeUVRenderTarget.texture.encoding]

      _setViewport(cubeUVRenderTarget, 0, 0, 3 * SIZE_MAX, 2 * SIZE_MAX)

      renderer.setRenderTarget(cubeUVRenderTarget)
      renderer.render(mesh, _flatCamera)
    }

    _proto._applyPMREM = function _applyPMREM(cubeUVRenderTarget) {
      var renderer = this._renderer
      var autoClear = renderer.autoClear
      renderer.autoClear = false

      for (var i = 1; i < TOTAL_LODS; i++) {
        var sigma = Math.sqrt(_sigmas[i] * _sigmas[i] - _sigmas[i - 1] * _sigmas[i - 1])
        var poleAxis = _axisDirections[(i - 1) % _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.
     */

    _proto._blur = function _blur(cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis) {
      var pingPongRenderTarget = this._pingPongRenderTarget

      this._halfBlur(cubeUVRenderTarget, pingPongRenderTarget, lodIn, lodOut, sigma, 'latitudinal', poleAxis)

      this._halfBlur(pingPongRenderTarget, cubeUVRenderTarget, lodOut, lodOut, sigma, 'longitudinal', poleAxis)
    }

    _proto._halfBlur = function _halfBlur(targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis) {
      var renderer = this._renderer
      var 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.

      var STANDARD_DEVIATIONS = 3
      var blurMesh = new Mesh(_lodPlanes[lodOut], blurMaterial)
      var blurUniforms = blurMaterial.uniforms
      var pixels = _sizeLods[lodIn] - 1
      var radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : (2 * Math.PI) / (2 * MAX_SAMPLES - 1)
      var sigmaPixels = sigmaRadians / radiansPerPixel
      var samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : MAX_SAMPLES

      if (samples > MAX_SAMPLES) {
        console.warn('sigmaRadians, ' + sigmaRadians + ', is too large and will clip, as it requested ' + samples + ' samples when the maximum is set to ' + MAX_SAMPLES)
      }

      var weights = []
      var sum = 0

      for (var i = 0; i < MAX_SAMPLES; ++i) {
        var _x = i / sigmaPixels

        var weight = Math.exp((-_x * _x) / 2)
        weights.push(weight)

        if (i == 0) {
          sum += weight
        } else if (i < samples) {
          sum += 2 * weight
        }
      }

      for (var _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
      }

      blurUniforms['dTheta'].value = radiansPerPixel
      blurUniforms['mipInt'].value = LOD_MAX - lodIn
      blurUniforms['inputEncoding'].value = ENCODINGS[targetIn.texture.encoding]
      blurUniforms['outputEncoding'].value = ENCODINGS[targetIn.texture.encoding]
      var outputSize = _sizeLods[lodOut]
      var x = 3 * Math.max(0, SIZE_MAX - 2 * outputSize)
      var y = (lodOut === 0 ? 0 : 2 * SIZE_MAX) + 2 * outputSize * (lodOut > LOD_MAX - LOD_MIN ? lodOut - LOD_MAX + LOD_MIN : 0)

      _setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize)

      renderer.setRenderTarget(targetOut)
      renderer.render(blurMesh, _flatCamera)
    }

    return PMREMGenerator
  })()

  function _isLDR(texture) {
    if (texture === undefined || texture.type !== UnsignedByteType) return false
    return texture.encoding === LinearEncoding || texture.encoding === sRGBEncoding || texture.encoding === GammaEncoding
  }

  function _createPlanes() {
    var _lodPlanes = []
    var _sizeLods = []
    var _sigmas = []
    var lod = LOD_MAX

    for (var i = 0; i < TOTAL_LODS; i++) {
      var sizeLod = Math.pow(2, lod)

      _sizeLods.push(sizeLod)

      var sigma = 1.0 / sizeLod

      if (i > LOD_MAX - LOD_MIN) {
        sigma = EXTRA_LOD_SIGMA[i - LOD_MAX + LOD_MIN - 1]
      } else if (i == 0) {
        sigma = 0
      }

      _sigmas.push(sigma)

      var texelSize = 1.0 / (sizeLod - 1)
      var min = -texelSize / 2
      var max = 1 + texelSize / 2
      var uv1 = [min, min, max, min, max, max, min, min, max, max, min, max]
      var cubeFaces = 6
      var vertices = 6
      var positionSize = 3
      var uvSize = 2
      var faceIndexSize = 1
      var position = new Float32Array(positionSize * vertices * cubeFaces)
      var uv = new Float32Array(uvSize * vertices * cubeFaces)
      var faceIndex = new Float32Array(faceIndexSize * vertices * cubeFaces)

      for (var face = 0; face < cubeFaces; face++) {
        var x = ((face % 3) * 2) / 3 - 1
        var y = face > 2 ? 0 : -1
        var 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)
        var fill = [face, face, face, face, face, face]
        faceIndex.set(fill, faceIndexSize * vertices * face)
      }

      var planes = new BufferGeometry()
      planes.setAttribute('position', new BufferAttribute(position, positionSize))
      planes.setAttribute('uv', new BufferAttribute(uv, uvSize))
      planes.setAttribute('faceIndex', new BufferAttribute(faceIndex, faceIndexSize))

      _lodPlanes.push(planes)

      if (lod > LOD_MIN) {
        lod--
      }
    }

    return {
      _lodPlanes: _lodPlanes,
      _sizeLods: _sizeLods,
      _sigmas: _sigmas
    }
  }

  function _createRenderTarget(params) {
    var cubeUVRenderTarget = new WebGLRenderTarget(3 * SIZE_MAX, 3 * SIZE_MAX, params)
    cubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping
    cubeUVRenderTarget.texture.name = 'PMREM.cubeUv'
    cubeUVRenderTarget.scissorTest = true
    return cubeUVRenderTarget
  }

  function _setViewport(target, x, y, width, height) {
    target.viewport.set(x, y, width, height)
    target.scissor.set(x, y, width, height)
  }

  function _getBlurShader(maxSamples) {
    var weights = new Float32Array(maxSamples)
    var poleAxis = new Vector3(0, 1, 0)
    var shaderMaterial = new RawShaderMaterial({
      name: 'SphericalGaussianBlur',
      defines: {
        n: maxSamples
      },
      uniforms: {
        envMap: {
          value: null
        },
        samples: {
          value: 1
        },
        weights: {
          value: weights
        },
        latitudinal: {
          value: false
        },
        dTheta: {
          value: 0
        },
        mipInt: {
          value: 0
        },
        poleAxis: {
          value: poleAxis
        },
        inputEncoding: {
          value: ENCODINGS[LinearEncoding]
        },
        outputEncoding: {
          value: ENCODINGS[LinearEncoding]
        }
      },
      vertexShader: _getCommonVertexShader(),
      fragmentShader:
        /* glsl */
        '\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform int samples;\n\t\t\tuniform float weights[ n ];\n\t\t\tuniform bool latitudinal;\n\t\t\tuniform float dTheta;\n\t\t\tuniform float mipInt;\n\t\t\tuniform vec3 poleAxis;\n\n\t\t\t' +
        _getEncodings() +
        "\n\n\t\t\t#define ENVMAP_TYPE_CUBE_UV\n\t\t\t#include <cube_uv_reflection_fragment>\n\n\t\t\tvec3 getSample( float theta, vec3 axis ) {\n\n\t\t\t\tfloat cosTheta = cos( theta );\n\t\t\t\t// Rodrigues' axis-angle rotation\n\t\t\t\tvec3 sampleDirection = vOutputDirection * cosTheta\n\t\t\t\t\t+ cross( axis, vOutputDirection ) * sin( theta )\n\t\t\t\t\t+ axis * dot( axis, vOutputDirection ) * ( 1.0 - cosTheta );\n\n\t\t\t\treturn bilinearCubeUV( envMap, sampleDirection, mipInt );\n\n\t\t\t}\n\n\t\t\tvoid main() {\n\n\t\t\t\tvec3 axis = latitudinal ? poleAxis : cross( poleAxis, vOutputDirection );\n\n\t\t\t\tif ( all( equal( axis, vec3( 0.0 ) ) ) ) {\n\n\t\t\t\t\taxis = vec3( vOutputDirection.z, 0.0, - vOutputDirection.x );\n\n\t\t\t\t}\n\n\t\t\t\taxis = normalize( axis );\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb += weights[ 0 ] * getSample( 0.0, axis );\n\n\t\t\t\tfor ( int i = 1; i < n; i++ ) {\n\n\t\t\t\t\tif ( i >= samples ) {\n\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t}\n\n\t\t\t\t\tfloat theta = dTheta * float( i );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( -1.0 * theta, axis );\n\t\t\t\t\tgl_FragColor.rgb += weights[ i ] * getSample( theta, axis );\n\n\t\t\t\t}\n\n\t\t\t\tgl_FragColor = linearToOutputTexel( gl_FragColor );\n\n\t\t\t}\n\t\t",
      blending: NoBlending,
      depthTest: false,
      depthWrite: false
    })
    return shaderMaterial
  }

  function _getEquirectShader() {
    var texelSize = new Vector2(1, 1)
    var shaderMaterial = new RawShaderMaterial({
      name: 'EquirectangularToCubeUV',
      uniforms: {
        envMap: {
          value: null
        },
        texelSize: {
          value: texelSize
        },
        inputEncoding: {
          value: ENCODINGS[LinearEncoding]
        },
        outputEncoding: {
          value: ENCODINGS[LinearEncoding]
        }
      },
      vertexShader: _getCommonVertexShader(),
      fragmentShader:
        /* glsl */
        '\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform sampler2D envMap;\n\t\t\tuniform vec2 texelSize;\n\n\t\t\t' +
        _getEncodings() +
        '\n\n\t\t\t#include <common>\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\n\t\t\t\tvec3 outputDirection = normalize( vOutputDirection );\n\t\t\t\tvec2 uv = equirectUv( outputDirection );\n\n\t\t\t\tvec2 f = fract( uv / texelSize - 0.5 );\n\t\t\t\tuv -= f * texelSize;\n\t\t\t\tvec3 tl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\t\t\t\tuv.x += texelSize.x;\n\t\t\t\tvec3 tr = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\t\t\t\tuv.y += texelSize.y;\n\t\t\t\tvec3 br = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\t\t\t\tuv.x -= texelSize.x;\n\t\t\t\tvec3 bl = envMapTexelToLinear( texture2D ( envMap, uv ) ).rgb;\n\n\t\t\t\tvec3 tm = mix( tl, tr, f.x );\n\t\t\t\tvec3 bm = mix( bl, br, f.x );\n\t\t\t\tgl_FragColor.rgb = mix( tm, bm, f.y );\n\n\t\t\t\tgl_FragColor = linearToOutputTexel( gl_FragColor );\n\n\t\t\t}\n\t\t',
      blending: NoBlending,
      depthTest: false,
      depthWrite: false
    })
    return shaderMaterial
  }

  function _getCubemapShader() {
    var shaderMaterial = new RawShaderMaterial({
      name: 'CubemapToCubeUV',
      uniforms: {
        envMap: {
          value: null
        },
        inputEncoding: {
          value: ENCODINGS[LinearEncoding]
        },
        outputEncoding: {
          value: ENCODINGS[LinearEncoding]
        }
      },
      vertexShader: _getCommonVertexShader(),
      fragmentShader:
        /* glsl */
        '\n\n\t\t\tprecision mediump float;\n\t\t\tprecision mediump int;\n\n\t\t\tvarying vec3 vOutputDirection;\n\n\t\t\tuniform samplerCube envMap;\n\n\t\t\t' +
        _getEncodings() +
        '\n\n\t\t\tvoid main() {\n\n\t\t\t\tgl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n\t\t\t\tgl_FragColor.rgb = envMapTexelToLinear( textureCube( envMap, vec3( - vOutputDirection.x, vOutputDirection.yz ) ) ).rgb;\n\t\t\t\tgl_FragColor = linearToOutputTexel( gl_FragColor );\n\n\t\t\t}\n\t\t',
      blending: NoBlending,
      depthTest: false,
      depthWrite: false
    })
    return shaderMaterial
  }

  function _getCommonVertexShader() {
    return (
      /* glsl */
      '\n\n\t\tprecision mediump float;\n\t\tprecision mediump int;\n\n\t\tattribute vec3 position;\n\t\tattribute vec2 uv;\n\t\tattribute float faceIndex;\n\n\t\tvarying vec3 vOutputDirection;\n\n\t\t// RH coordinate system; PMREM face-indexing convention\n\t\tvec3 getDirection( vec2 uv, float face ) {\n\n\t\t\tuv = 2.0 * uv - 1.0;\n\n\t\t\tvec3 direction = vec3( uv, 1.0 );\n\n\t\t\tif ( face == 0.0 ) {\n\n\t\t\t\tdirection = direction.zyx; // ( 1, v, u ) pos x\n\n\t\t\t} else if ( face == 1.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xz *= -1.0; // ( -u, 1, -v ) pos y\n\n\t\t\t} else if ( face == 2.0 ) {\n\n\t\t\t\tdirection.x *= -1.0; // ( -u, v, 1 ) pos z\n\n\t\t\t} else if ( face == 3.0 ) {\n\n\t\t\t\tdirection = direction.zyx;\n\t\t\t\tdirection.xz *= -1.0; // ( -1, v, -u ) neg x\n\n\t\t\t} else if ( face == 4.0 ) {\n\n\t\t\t\tdirection = direction.xzy;\n\t\t\t\tdirection.xy *= -1.0; // ( -u, -1, v ) neg y\n\n\t\t\t} else if ( face == 5.0 ) {\n\n\t\t\t\tdirection.z *= -1.0; // ( u, v, -1 ) neg z\n\n\t\t\t}\n\n\t\t\treturn direction;\n\n\t\t}\n\n\t\tvoid main() {\n\n\t\t\tvOutputDirection = getDirection( uv, faceIndex );\n\t\t\tgl_Position = vec4( position, 1.0 );\n\n\t\t}\n\t'
    )
  }

  function _getEncodings() {
    return (
      /* glsl */
      '\n\n\t\tuniform int inputEncoding;\n\t\tuniform int outputEncoding;\n\n\t\t#include <encodings_pars_fragment>\n\n\t\tvec4 inputTexelToLinear( vec4 value ) {\n\n\t\t\tif ( inputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( inputEncoding == 1 ) {\n\n\t\t\t\treturn sRGBToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 2 ) {\n\n\t\t\t\treturn RGBEToLinear( value );\n\n\t\t\t} else if ( inputEncoding == 3 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 7.0 );\n\n\t\t\t} else if ( inputEncoding == 4 ) {\n\n\t\t\t\treturn RGBMToLinear( value, 16.0 );\n\n\t\t\t} else if ( inputEncoding == 5 ) {\n\n\t\t\t\treturn RGBDToLinear( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn GammaToLinear( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 linearToOutputTexel( vec4 value ) {\n\n\t\t\tif ( outputEncoding == 0 ) {\n\n\t\t\t\treturn value;\n\n\t\t\t} else if ( outputEncoding == 1 ) {\n\n\t\t\t\treturn LinearTosRGB( value );\n\n\t\t\t} else if ( outputEncoding == 2 ) {\n\n\t\t\t\treturn LinearToRGBE( value );\n\n\t\t\t} else if ( outputEncoding == 3 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 7.0 );\n\n\t\t\t} else if ( outputEncoding == 4 ) {\n\n\t\t\t\treturn LinearToRGBM( value, 16.0 );\n\n\t\t\t} else if ( outputEncoding == 5 ) {\n\n\t\t\t\treturn LinearToRGBD( value, 256.0 );\n\n\t\t\t} else {\n\n\t\t\t\treturn LinearToGamma( value, 2.2 );\n\n\t\t\t}\n\n\t\t}\n\n\t\tvec4 envMapTexelToLinear( vec4 color ) {\n\n\t\t\treturn inputTexelToLinear( color );\n\n\t\t}\n\t'
    )
  }

  function Face4(a, b, c, d, normal, color, materialIndex) {
    console.warn('THREE.Face4 has been removed. A THREE.Face3 will be created instead.')
    return new Face3(a, b, c, normal, color, materialIndex)
  }
  var LineStrip = 0
  var LinePieces = 1
  var NoColors = 0
  var FaceColors = 1
  var VertexColors = 2
  function MeshFaceMaterial(materials) {
    console.warn('THREE.MeshFaceMaterial has been removed. Use an Array instead.')
    return materials
  }
  function MultiMaterial(materials) {
    if (materials === void 0) {
      materials = []
    }

    console.warn('THREE.MultiMaterial has been removed. Use an Array instead.')
    materials.isMultiMaterial = true
    materials.materials = materials

    materials.clone = function () {
      return materials.slice()
    }

    return materials
  }
  function PointCloud(geometry, material) {
    console.warn('THREE.PointCloud has been renamed to THREE.Points.')
    return new Points(geometry, material)
  }
  function Particle(material) {
    console.warn('THREE.Particle has been renamed to THREE.Sprite.')
    return new Sprite(material)
  }
  function ParticleSystem(geometry, material) {
    console.warn('THREE.ParticleSystem has been renamed to THREE.Points.')
    return new Points(geometry, material)
  }
  function PointCloudMaterial(parameters) {
    console.warn('THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.')
    return new PointsMaterial(parameters)
  }
  function ParticleBasicMaterial(parameters) {
    console.warn('THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.')
    return new PointsMaterial(parameters)
  }
  function ParticleSystemMaterial(parameters) {
    console.warn('THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.')
    return new PointsMaterial(parameters)
  }
  function Vertex(x, y, z) {
    console.warn('THREE.Vertex has been removed. Use THREE.Vector3 instead.')
    return new Vector3(x, y, z)
  } //

  function DynamicBufferAttribute(array, itemSize) {
    console.warn('THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setUsage( THREE.DynamicDrawUsage ) instead.')
    return new BufferAttribute(array, itemSize).setUsage(DynamicDrawUsage)
  }
  function Int8Attribute(array, itemSize) {
    console.warn('THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.')
    return new Int8BufferAttribute(array, itemSize)
  }
  function Uint8Attribute(array, itemSize) {
    console.warn('THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.')
    return new Uint8BufferAttribute(array, itemSize)
  }
  function Uint8ClampedAttribute(array, itemSize) {
    console.warn('THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.')
    return new Uint8ClampedBufferAttribute(array, itemSize)
  }
  function Int16Attribute(array, itemSize) {
    console.warn('THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.')
    return new Int16BufferAttribute(array, itemSize)
  }
  function Uint16Attribute(array, itemSize) {
    console.warn('THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.')
    return new Uint16BufferAttribute(array, itemSize)
  }
  function Int32Attribute(array, itemSize) {
    console.warn('THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.')
    return new Int32BufferAttribute(array, itemSize)
  }
  function Uint32Attribute(array, itemSize) {
    console.warn('THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.')
    return new Uint32BufferAttribute(array, itemSize)
  }
  function Float32Attribute(array, itemSize) {
    console.warn('THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.')
    return new Float32BufferAttribute(array, itemSize)
  }
  function Float64Attribute(array, itemSize) {
    console.warn('THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.')
    return new Float64BufferAttribute(array, itemSize)
  } //

  Curve.create = function (construct, getPoint) {
    console.log('THREE.Curve.create() has been deprecated')
    construct.prototype = Object.create(Curve.prototype)
    construct.prototype.constructor = construct
    construct.prototype.getPoint = getPoint
    return construct
  } //

  Object.assign(CurvePath.prototype, {
    createPointsGeometry: function createPointsGeometry(divisions) {
      console.warn('THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.') // generate geometry from path points (for Line or Points objects)

      var pts = this.getPoints(divisions)
      return this.createGeometry(pts)
    },
    createSpacedPointsGeometry: function createSpacedPointsGeometry(divisions) {
      console.warn('THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.') // generate geometry from equidistant sampling along the path

      var pts = this.getSpacedPoints(divisions)
      return this.createGeometry(pts)
    },
    createGeometry: function createGeometry(points) {
      console.warn('THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.')
      var geometry = new Geometry()

      for (var i = 0, l = points.length; i < l; i++) {
        var point = points[i]
        geometry.vertices.push(new Vector3(point.x, point.y, point.z || 0))
      }

      return geometry
    }
  }) //

  Object.assign(Path.prototype, {
    fromPoints: function fromPoints(points) {
      console.warn('THREE.Path: .fromPoints() has been renamed to .setFromPoints().')
      return this.setFromPoints(points)
    }
  }) //

  function ClosedSplineCurve3(points) {
    console.warn('THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.')
    CatmullRomCurve3.call(this, points)
    this.type = 'catmullrom'
    this.closed = true
  }
  ClosedSplineCurve3.prototype = Object.create(CatmullRomCurve3.prototype) //

  function SplineCurve3(points) {
    console.warn('THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.')
    CatmullRomCurve3.call(this, points)
    this.type = 'catmullrom'
  }
  SplineCurve3.prototype = Object.create(CatmullRomCurve3.prototype) //

  function Spline(points) {
    console.warn('THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.')
    CatmullRomCurve3.call(this, points)
    this.type = 'catmullrom'
  }
  Spline.prototype = Object.create(CatmullRomCurve3.prototype)
  Object.assign(Spline.prototype, {
    initFromArray: function initFromArray() /* a */
    {
      console.error('THREE.Spline: .initFromArray() has been removed.')
    },
    getControlPointsArray: function getControlPointsArray() /* optionalTarget */
    {
      console.error('THREE.Spline: .getControlPointsArray() has been removed.')
    },
    reparametrizeByArcLength: function reparametrizeByArcLength() /* samplingCoef */
    {
      console.error('THREE.Spline: .reparametrizeByArcLength() has been removed.')
    }
  }) //

  function AxisHelper(size) {
    console.warn('THREE.AxisHelper has been renamed to THREE.AxesHelper.')
    return new AxesHelper(size)
  }
  function BoundingBoxHelper(object, color) {
    console.warn('THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.')
    return new BoxHelper(object, color)
  }
  function EdgesHelper(object, hex) {
    console.warn('THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.')
    return new LineSegments(
      new EdgesGeometry(object.geometry),
      new LineBasicMaterial({
        color: hex !== undefined ? hex : 0xffffff
      })
    )
  }

  GridHelper.prototype.setColors = function () {
    console.error('THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.')
  }

  SkeletonHelper.prototype.update = function () {
    console.error('THREE.SkeletonHelper: update() no longer needs to be called.')
  }

  function WireframeHelper(object, hex) {
    console.warn('THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.')
    return new LineSegments(
      new WireframeGeometry(object.geometry),
      new LineBasicMaterial({
        color: hex !== undefined ? hex : 0xffffff
      })
    )
  } //

  Object.assign(Loader.prototype, {
    extractUrlBase: function extractUrlBase(url) {
      console.warn('THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.')
      return LoaderUtils.extractUrlBase(url)
    }
  })
  Loader.Handlers = {
    add: function add() /* regex, loader */
    {
      console.error('THREE.Loader: Handlers.add() has been removed. Use LoadingManager.addHandler() instead.')
    },
    get: function get() /* file */
    {
      console.error('THREE.Loader: Handlers.get() has been removed. Use LoadingManager.getHandler() instead.')
    }
  }
  function XHRLoader(manager) {
    console.warn('THREE.XHRLoader has been renamed to THREE.FileLoader.')
    return new FileLoader(manager)
  }
  function BinaryTextureLoader(manager) {
    console.warn('THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.')
    return new DataTextureLoader(manager)
  } //

  Object.assign(Box2.prototype, {
    center: function center(optionalTarget) {
      console.warn('THREE.Box2: .center() has been renamed to .getCenter().')
      return this.getCenter(optionalTarget)
    },
    empty: function empty() {
      console.warn('THREE.Box2: .empty() has been renamed to .isEmpty().')
      return this.isEmpty()
    },
    isIntersectionBox: function isIntersectionBox(box) {
      console.warn('THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().')
      return this.intersectsBox(box)
    },
    size: function size(optionalTarget) {
      console.warn('THREE.Box2: .size() has been renamed to .getSize().')
      return this.getSize(optionalTarget)
    }
  })
  Object.assign(Box3.prototype, {
    center: function center(optionalTarget) {
      console.warn('THREE.Box3: .center() has been renamed to .getCenter().')
      return this.getCenter(optionalTarget)
    },
    empty: function empty() {
      console.warn('THREE.Box3: .empty() has been renamed to .isEmpty().')
      return this.isEmpty()
    },
    isIntersectionBox: function isIntersectionBox(box) {
      console.warn('THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().')
      return this.intersectsBox(box)
    },
    isIntersectionSphere: function isIntersectionSphere(sphere) {
      console.warn('THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().')
      return this.intersectsSphere(sphere)
    },
    size: function size(optionalTarget) {
      console.warn('THREE.Box3: .size() has been renamed to .getSize().')
      return this.getSize(optionalTarget)
    }
  })
  Object.assign(Sphere.prototype, {
    empty: function empty() {
      console.warn('THREE.Sphere: .empty() has been renamed to .isEmpty().')
      return this.isEmpty()
    }
  })

  Frustum.prototype.setFromMatrix = function (m) {
    console.warn('THREE.Frustum: .setFromMatrix() has been renamed to .setFromProjectionMatrix().')
    return this.setFromProjectionMatrix(m)
  }

  Line3.prototype.center = function (optionalTarget) {
    console.warn('THREE.Line3: .center() has been renamed to .getCenter().')
    return this.getCenter(optionalTarget)
  }

  Object.assign(MathUtils, {
    random16: function random16() {
      console.warn('THREE.Math: .random16() has been deprecated. Use Math.random() instead.')
      return Math.random()
    },
    nearestPowerOfTwo: function nearestPowerOfTwo(value) {
      console.warn('THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().')
      return MathUtils.floorPowerOfTwo(value)
    },
    nextPowerOfTwo: function nextPowerOfTwo(value) {
      console.warn('THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().')
      return MathUtils.ceilPowerOfTwo(value)
    }
  })
  Object.assign(Matrix3.prototype, {
    flattenToArrayOffset: function flattenToArrayOffset(array, offset) {
      console.warn('THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.')
      return this.toArray(array, offset)
    },
    multiplyVector3: function multiplyVector3(vector) {
      console.warn('THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.')
      return vector.applyMatrix3(this)
    },
    multiplyVector3Array: function multiplyVector3Array() /* a */
    {
      console.error('THREE.Matrix3: .multiplyVector3Array() has been removed.')
    },
    applyToBufferAttribute: function applyToBufferAttribute(attribute) {
      console.warn('THREE.Matrix3: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix3( matrix ) instead.')
      return attribute.applyMatrix3(this)
    },
    applyToVector3Array: function applyToVector3Array() /* array, offset, length */
    {
      console.error('THREE.Matrix3: .applyToVector3Array() has been removed.')
    },
    getInverse: function getInverse(matrix) {
      console.warn('THREE.Matrix3: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead.')
      return this.copy(matrix).invert()
    }
  })
  Object.assign(Matrix4.prototype, {
    extractPosition: function extractPosition(m) {
      console.warn('THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().')
      return this.copyPosition(m)
    },
    flattenToArrayOffset: function flattenToArrayOffset(array, offset) {
      console.warn('THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.')
      return this.toArray(array, offset)
    },
    getPosition: function getPosition() {
      console.warn('THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.')
      return new Vector3().setFromMatrixColumn(this, 3)
    },
    setRotationFromQuaternion: function setRotationFromQuaternion(q) {
      console.warn('THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().')
      return this.makeRotationFromQuaternion(q)
    },
    multiplyToArray: function multiplyToArray() {
      console.warn('THREE.Matrix4: .multiplyToArray() has been removed.')
    },
    multiplyVector3: function multiplyVector3(vector) {
      console.warn('THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.')
      return vector.applyMatrix4(this)
    },
    multiplyVector4: function multiplyVector4(vector) {
      console.warn('THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.')
      return vector.applyMatrix4(this)
    },
    multiplyVector3Array: function multiplyVector3Array() /* a */
    {
      console.error('THREE.Matrix4: .multiplyVector3Array() has been removed.')
    },
    rotateAxis: function rotateAxis(v) {
      console.warn('THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.')
      v.transformDirection(this)
    },
    crossVector: function crossVector(vector) {
      console.warn('THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.')
      return vector.applyMatrix4(this)
    },
    translate: function translate() {
      console.error('THREE.Matrix4: .translate() has been removed.')
    },
    rotateX: function rotateX() {
      console.error('THREE.Matrix4: .rotateX() has been removed.')
    },
    rotateY: function rotateY() {
      console.error('THREE.Matrix4: .rotateY() has been removed.')
    },
    rotateZ: function rotateZ() {
      console.error('THREE.Matrix4: .rotateZ() has been removed.')
    },
    rotateByAxis: function rotateByAxis() {
      console.error('THREE.Matrix4: .rotateByAxis() has been removed.')
    },
    applyToBufferAttribute: function applyToBufferAttribute(attribute) {
      console.warn('THREE.Matrix4: .applyToBufferAttribute() has been removed. Use attribute.applyMatrix4( matrix ) instead.')
      return attribute.applyMatrix4(this)
    },
    applyToVector3Array: function applyToVector3Array() /* array, offset, length */
    {
      console.error('THREE.Matrix4: .applyToVector3Array() has been removed.')
    },
    makeFrustum: function makeFrustum(left, right, bottom, top, near, far) {
      console.warn('THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.')
      return this.makePerspective(left, right, top, bottom, near, far)
    },
    getInverse: function getInverse(matrix) {
      console.warn('THREE.Matrix4: .getInverse() has been removed. Use matrixInv.copy( matrix ).invert(); instead.')
      return this.copy(matrix).invert()
    }
  })

  Plane.prototype.isIntersectionLine = function (line) {
    console.warn('THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().')
    return this.intersectsLine(line)
  }

  Object.assign(Quaternion.prototype, {
    multiplyVector3: function multiplyVector3(vector) {
      console.warn('THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.')
      return vector.applyQuaternion(this)
    },
    inverse: function inverse() {
      console.warn('THREE.Quaternion: .inverse() has been renamed to invert().')
      return this.invert()
    }
  })
  Object.assign(Ray.prototype, {
    isIntersectionBox: function isIntersectionBox(box) {
      console.warn('THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().')
      return this.intersectsBox(box)
    },
    isIntersectionPlane: function isIntersectionPlane(plane) {
      console.warn('THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().')
      return this.intersectsPlane(plane)
    },
    isIntersectionSphere: function isIntersectionSphere(sphere) {
      console.warn('THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().')
      return this.intersectsSphere(sphere)
    }
  })
  Object.assign(Triangle.prototype, {
    area: function area() {
      console.warn('THREE.Triangle: .area() has been renamed to .getArea().')
      return this.getArea()
    },
    barycoordFromPoint: function barycoordFromPoint(point, target) {
      console.warn('THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().')
      return this.getBarycoord(point, target)
    },
    midpoint: function midpoint(target) {
      console.warn('THREE.Triangle: .midpoint() has been renamed to .getMidpoint().')
      return this.getMidpoint(target)
    },
    normal: function normal(target) {
      console.warn('THREE.Triangle: .normal() has been renamed to .getNormal().')
      return this.getNormal(target)
    },
    plane: function plane(target) {
      console.warn('THREE.Triangle: .plane() has been renamed to .getPlane().')
      return this.getPlane(target)
    }
  })
  Object.assign(Triangle, {
    barycoordFromPoint: function barycoordFromPoint(point, a, b, c, target) {
      console.warn('THREE.Triangle: .barycoordFromPoint() has been renamed to .getBarycoord().')
      return Triangle.getBarycoord(point, a, b, c, target)
    },
    normal: function normal(a, b, c, target) {
      console.warn('THREE.Triangle: .normal() has been renamed to .getNormal().')
      return Triangle.getNormal(a, b, c, target)
    }
  })
  Object.assign(Shape.prototype, {
    extractAllPoints: function extractAllPoints(divisions) {
      console.warn('THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.')
      return this.extractPoints(divisions)
    },
    extrude: function extrude(options) {
      console.warn('THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.')
      return new ExtrudeGeometry(this, options)
    },
    makeGeometry: function makeGeometry(options) {
      console.warn('THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.')
      return new ShapeGeometry(this, options)
    }
  })
  Object.assign(Vector2.prototype, {
    fromAttribute: function fromAttribute(attribute, index, offset) {
      console.warn('THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().')
      return this.fromBufferAttribute(attribute, index, offset)
    },
    distanceToManhattan: function distanceToManhattan(v) {
      console.warn('THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().')
      return this.manhattanDistanceTo(v)
    },
    lengthManhattan: function lengthManhattan() {
      console.warn('THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().')
      return this.manhattanLength()
    }
  })
  Object.assign(Vector3.prototype, {
    setEulerFromRotationMatrix: function setEulerFromRotationMatrix() {
      console.error('THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.')
    },
    setEulerFromQuaternion: function setEulerFromQuaternion() {
      console.error('THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.')
    },
    getPositionFromMatrix: function getPositionFromMatrix(m) {
      console.warn('THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().')
      return this.setFromMatrixPosition(m)
    },
    getScaleFromMatrix: function getScaleFromMatrix(m) {
      console.warn('THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().')
      return this.setFromMatrixScale(m)
    },
    getColumnFromMatrix: function getColumnFromMatrix(index, matrix) {
      console.warn('THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().')
      return this.setFromMatrixColumn(matrix, index)
    },
    applyProjection: function applyProjection(m) {
      console.warn('THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.')
      return this.applyMatrix4(m)
    },
    fromAttribute: function fromAttribute(attribute, index, offset) {
      console.warn('THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().')
      return this.fromBufferAttribute(attribute, index, offset)
    },
    distanceToManhattan: function distanceToManhattan(v) {
      console.warn('THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().')
      return this.manhattanDistanceTo(v)
    },
    lengthManhattan: function lengthManhattan() {
      console.warn('THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().')
      return this.manhattanLength()
    }
  })
  Object.assign(Vector4.prototype, {
    fromAttribute: function fromAttribute(attribute, index, offset) {
      console.warn('THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().')
      return this.fromBufferAttribute(attribute, index, offset)
    },
    lengthManhattan: function lengthManhattan() {
      console.warn('THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().')
      return this.manhattanLength()
    }
  }) //

  Object.assign(Geometry.prototype, {
    computeTangents: function computeTangents() {
      console.error('THREE.Geometry: .computeTangents() has been removed.')
    },
    computeLineDistances: function computeLineDistances() {
      console.error('THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead.')
    },
    applyMatrix: function applyMatrix(matrix) {
      console.warn('THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().')
      return this.applyMatrix4(matrix)
    }
  })
  Object.assign(Object3D.prototype, {
    getChildByName: function getChildByName(name) {
      console.warn('THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().')
      return this.getObjectByName(name)
    },
    renderDepth: function renderDepth() {
      console.warn('THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.')
    },
    translate: function translate(distance, axis) {
      console.warn('THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.')
      return this.translateOnAxis(axis, distance)
    },
    getWorldRotation: function getWorldRotation() {
      console.error('THREE.Object3D: .getWorldRotation() has been removed. Use THREE.Object3D.getWorldQuaternion( target ) instead.')
    },
    applyMatrix: function applyMatrix(matrix) {
      console.warn('THREE.Object3D: .applyMatrix() has been renamed to .applyMatrix4().')
      return this.applyMatrix4(matrix)
    }
  })
  Object.defineProperties(Object3D.prototype, {
    eulerOrder: {
      get: function get() {
        console.warn('THREE.Object3D: .eulerOrder is now .rotation.order.')
        return this.rotation.order
      },
      set: function set(value) {
        console.warn('THREE.Object3D: .eulerOrder is now .rotation.order.')
        this.rotation.order = value
      }
    },
    useQuaternion: {
      get: function get() {
        console.warn('THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.')
      },
      set: function set() {
        console.warn('THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.')
      }
    }
  })
  Object.assign(Mesh.prototype, {
    setDrawMode: function setDrawMode() {
      console.error(
        'THREE.Mesh: .setDrawMode() has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.'
      )
    }
  })
  Object.defineProperties(Mesh.prototype, {
    drawMode: {
      get: function get() {
        console.error('THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode.')
        return TrianglesDrawMode
      },
      set: function set() {
        console.error(
          'THREE.Mesh: .drawMode has been removed. The renderer now always assumes THREE.TrianglesDrawMode. Transform your geometry via BufferGeometryUtils.toTrianglesDrawMode() if necessary.'
        )
      }
    }
  })
  Object.defineProperties(LOD.prototype, {
    objects: {
      get: function get() {
        console.warn('THREE.LOD: .objects has been renamed to .levels.')
        return this.levels
      }
    }
  })
  Object.defineProperty(Skeleton.prototype, 'useVertexTexture', {
    get: function get() {
      console.warn('THREE.Skeleton: useVertexTexture has been removed.')
    },
    set: function set() {
      console.warn('THREE.Skeleton: useVertexTexture has been removed.')
    }
  })

  SkinnedMesh.prototype.initBones = function () {
    console.error('THREE.SkinnedMesh: initBones() has been removed.')
  }

  Object.defineProperty(Curve.prototype, '__arcLengthDivisions', {
    get: function get() {
      console.warn('THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.')
      return this.arcLengthDivisions
    },
    set: function set(value) {
      console.warn('THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.')
      this.arcLengthDivisions = value
    }
  }) //

  PerspectiveCamera.prototype.setLens = function (focalLength, filmGauge) {
    console.warn('THREE.PerspectiveCamera.setLens is deprecated. ' + 'Use .setFocalLength and .filmGauge for a photographic setup.')
    if (filmGauge !== undefined) this.filmGauge = filmGauge
    this.setFocalLength(focalLength)
  } //

  Object.defineProperties(Light.prototype, {
    onlyShadow: {
      set: function set() {
        console.warn('THREE.Light: .onlyShadow has been removed.')
      }
    },
    shadowCameraFov: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraFov is now .shadow.camera.fov.')
        this.shadow.camera.fov = value
      }
    },
    shadowCameraLeft: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraLeft is now .shadow.camera.left.')
        this.shadow.camera.left = value
      }
    },
    shadowCameraRight: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraRight is now .shadow.camera.right.')
        this.shadow.camera.right = value
      }
    },
    shadowCameraTop: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraTop is now .shadow.camera.top.')
        this.shadow.camera.top = value
      }
    },
    shadowCameraBottom: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.')
        this.shadow.camera.bottom = value
      }
    },
    shadowCameraNear: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraNear is now .shadow.camera.near.')
        this.shadow.camera.near = value
      }
    },
    shadowCameraFar: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowCameraFar is now .shadow.camera.far.')
        this.shadow.camera.far = value
      }
    },
    shadowCameraVisible: {
      set: function set() {
        console.warn('THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.')
      }
    },
    shadowBias: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowBias is now .shadow.bias.')
        this.shadow.bias = value
      }
    },
    shadowDarkness: {
      set: function set() {
        console.warn('THREE.Light: .shadowDarkness has been removed.')
      }
    },
    shadowMapWidth: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.')
        this.shadow.mapSize.width = value
      }
    },
    shadowMapHeight: {
      set: function set(value) {
        console.warn('THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.')
        this.shadow.mapSize.height = value
      }
    }
  }) //

  Object.defineProperties(BufferAttribute.prototype, {
    length: {
      get: function get() {
        console.warn('THREE.BufferAttribute: .length has been deprecated. Use .count instead.')
        return this.array.length
      }
    },
    dynamic: {
      get: function get() {
        console.warn('THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead.')
        return this.usage === DynamicDrawUsage
      },
      set: function set() /* value */
      {
        console.warn('THREE.BufferAttribute: .dynamic has been deprecated. Use .usage instead.')
        this.setUsage(DynamicDrawUsage)
      }
    }
  })
  Object.assign(BufferAttribute.prototype, {
    setDynamic: function setDynamic(value) {
      console.warn('THREE.BufferAttribute: .setDynamic() has been deprecated. Use .setUsage() instead.')
      this.setUsage(value === true ? DynamicDrawUsage : StaticDrawUsage)
      return this
    },
    copyIndicesArray: function copyIndicesArray() /* indices */
    {
      console.error('THREE.BufferAttribute: .copyIndicesArray() has been removed.')
    },
    setArray: function setArray() /* array */
    {
      console.error('THREE.BufferAttribute: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers')
    }
  })
  Object.assign(BufferGeometry.prototype, {
    addIndex: function addIndex(index) {
      console.warn('THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().')
      this.setIndex(index)
    },
    addAttribute: function addAttribute(name, attribute) {
      console.warn('THREE.BufferGeometry: .addAttribute() has been renamed to .setAttribute().')

      if (!(attribute && attribute.isBufferAttribute) && !(attribute && attribute.isInterleavedBufferAttribute)) {
        console.warn('THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).')
        return this.setAttribute(name, new BufferAttribute(arguments[1], arguments[2]))
      }

      if (name === 'index') {
        console.warn('THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.')
        this.setIndex(attribute)
        return this
      }

      return this.setAttribute(name, attribute)
    },
    addDrawCall: function addDrawCall(start, count, indexOffset) {
      if (indexOffset !== undefined) {
        console.warn('THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.')
      }

      console.warn('THREE.BufferGeometry: .addDrawCall() is now .addGroup().')
      this.addGroup(start, count)
    },
    clearDrawCalls: function clearDrawCalls() {
      console.warn('THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().')
      this.clearGroups()
    },
    computeTangents: function computeTangents() {
      console.warn('THREE.BufferGeometry: .computeTangents() has been removed.')
    },
    computeOffsets: function computeOffsets() {
      console.warn('THREE.BufferGeometry: .computeOffsets() has been removed.')
    },
    removeAttribute: function removeAttribute(name) {
      console.warn('THREE.BufferGeometry: .removeAttribute() has been renamed to .deleteAttribute().')
      return this.deleteAttribute(name)
    },
    applyMatrix: function applyMatrix(matrix) {
      console.warn('THREE.BufferGeometry: .applyMatrix() has been renamed to .applyMatrix4().')
      return this.applyMatrix4(matrix)
    }
  })
  Object.defineProperties(BufferGeometry.prototype, {
    drawcalls: {
      get: function get() {
        console.error('THREE.BufferGeometry: .drawcalls has been renamed to .groups.')
        return this.groups
      }
    },
    offsets: {
      get: function get() {
        console.warn('THREE.BufferGeometry: .offsets has been renamed to .groups.')
        return this.groups
      }
    }
  })
  Object.defineProperties(InstancedBufferGeometry.prototype, {
    maxInstancedCount: {
      get: function get() {
        console.warn('THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount.')
        return this.instanceCount
      },
      set: function set(value) {
        console.warn('THREE.InstancedBufferGeometry: .maxInstancedCount has been renamed to .instanceCount.')
        this.instanceCount = value
      }
    }
  })
  Object.defineProperties(Raycaster.prototype, {
    linePrecision: {
      get: function get() {
        console.warn('THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead.')
        return this.params.Line.threshold
      },
      set: function set(value) {
        console.warn('THREE.Raycaster: .linePrecision has been deprecated. Use .params.Line.threshold instead.')
        this.params.Line.threshold = value
      }
    }
  })
  Object.defineProperties(InterleavedBuffer.prototype, {
    dynamic: {
      get: function get() {
        console.warn('THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead.')
        return this.usage === DynamicDrawUsage
      },
      set: function set(value) {
        console.warn('THREE.InterleavedBuffer: .length has been deprecated. Use .usage instead.')
        this.setUsage(value)
      }
    }
  })
  Object.assign(InterleavedBuffer.prototype, {
    setDynamic: function setDynamic(value) {
      console.warn('THREE.InterleavedBuffer: .setDynamic() has been deprecated. Use .setUsage() instead.')
      this.setUsage(value === true ? DynamicDrawUsage : StaticDrawUsage)
      return this
    },
    setArray: function setArray() /* array */
    {
      console.error('THREE.InterleavedBuffer: .setArray has been removed. Use BufferGeometry .setAttribute to replace/resize attribute buffers')
    }
  }) //

  Object.assign(ExtrudeBufferGeometry.prototype, {
    getArrays: function getArrays() {
      console.error('THREE.ExtrudeBufferGeometry: .getArrays() has been removed.')
    },
    addShapeList: function addShapeList() {
      console.error('THREE.ExtrudeBufferGeometry: .addShapeList() has been removed.')
    },
    addShape: function addShape() {
      console.error('THREE.ExtrudeBufferGeometry: .addShape() has been removed.')
    }
  }) //

  Object.assign(Scene.prototype, {
    dispose: function dispose() {
      console.error('THREE.Scene: .dispose() has been removed.')
    }
  }) //

  Object.defineProperties(Uniform.prototype, {
    dynamic: {
      set: function set() {
        console.warn('THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.')
      }
    },
    onUpdate: {
      value: function value() {
        console.warn('THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.')
        return this
      }
    }
  }) //

  Object.defineProperties(Material.prototype, {
    wrapAround: {
      get: function get() {
        console.warn('THREE.Material: .wrapAround has been removed.')
      },
      set: function set() {
        console.warn('THREE.Material: .wrapAround has been removed.')
      }
    },
    overdraw: {
      get: function get() {
        console.warn('THREE.Material: .overdraw has been removed.')
      },
      set: function set() {
        console.warn('THREE.Material: .overdraw has been removed.')
      }
    },
    wrapRGB: {
      get: function get() {
        console.warn('THREE.Material: .wrapRGB has been removed.')
        return new Color()
      }
    },
    shading: {
      get: function get() {
        console.error('THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.')
      },
      set: function set(value) {
        console.warn('THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.')
        this.flatShading = value === FlatShading
      }
    },
    stencilMask: {
      get: function get() {
        console.warn('THREE.' + this.type + ': .stencilMask has been removed. Use .stencilFuncMask instead.')
        return this.stencilFuncMask
      },
      set: function set(value) {
        console.warn('THREE.' + this.type + ': .stencilMask has been removed. Use .stencilFuncMask instead.')
        this.stencilFuncMask = value
      }
    }
  })
  Object.defineProperties(MeshPhongMaterial.prototype, {
    metal: {
      get: function get() {
        console.warn('THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.')
        return false
      },
      set: function set() {
        console.warn('THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead')
      }
    }
  })
  Object.defineProperties(MeshPhysicalMaterial.prototype, {
    transparency: {
      get: function get() {
        console.warn('THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission.')
        return this.transmission
      },
      set: function set(value) {
        console.warn('THREE.MeshPhysicalMaterial: .transparency has been renamed to .transmission.')
        this.transmission = value
      }
    }
  })
  Object.defineProperties(ShaderMaterial.prototype, {
    derivatives: {
      get: function get() {
        console.warn('THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.')
        return this.extensions.derivatives
      },
      set: function set(value) {
        console.warn('THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.')
        this.extensions.derivatives = value
      }
    }
  }) //

  Object.assign(WebGLRenderer.prototype, {
    clearTarget: function clearTarget(renderTarget, color, depth, stencil) {
      console.warn('THREE.WebGLRenderer: .clearTarget() has been deprecated. Use .setRenderTarget() and .clear() instead.')
      this.setRenderTarget(renderTarget)
      this.clear(color, depth, stencil)
    },
    animate: function animate(callback) {
      console.warn('THREE.WebGLRenderer: .animate() is now .setAnimationLoop().')
      this.setAnimationLoop(callback)
    },
    getCurrentRenderTarget: function getCurrentRenderTarget() {
      console.warn('THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().')
      return this.getRenderTarget()
    },
    getMaxAnisotropy: function getMaxAnisotropy() {
      console.warn('THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().')
      return this.capabilities.getMaxAnisotropy()
    },
    getPrecision: function getPrecision() {
      console.warn('THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.')
      return this.capabilities.precision
    },
    resetGLState: function resetGLState() {
      console.warn('THREE.WebGLRenderer: .resetGLState() is now .state.reset().')
      return this.state.reset()
    },
    supportsFloatTextures: function supportsFloatTextures() {
      console.warn("THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( 'OES_texture_float' ).")
      return this.extensions.get('OES_texture_float')
    },
    supportsHalfFloatTextures: function supportsHalfFloatTextures() {
      console.warn("THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( 'OES_texture_half_float' ).")
      return this.extensions.get('OES_texture_half_float')
    },
    supportsStandardDerivatives: function supportsStandardDerivatives() {
      console.warn("THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( 'OES_standard_derivatives' ).")
      return this.extensions.get('OES_standard_derivatives')
    },
    supportsCompressedTextureS3TC: function supportsCompressedTextureS3TC() {
      console.warn("THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( 'WEBGL_compressed_texture_s3tc' ).")
      return this.extensions.get('WEBGL_compressed_texture_s3tc')
    },
    supportsCompressedTexturePVRTC: function supportsCompressedTexturePVRTC() {
      console.warn("THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( 'WEBGL_compressed_texture_pvrtc' ).")
      return this.extensions.get('WEBGL_compressed_texture_pvrtc')
    },
    supportsBlendMinMax: function supportsBlendMinMax() {
      console.warn("THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( 'EXT_blend_minmax' ).")
      return this.extensions.get('EXT_blend_minmax')
    },
    supportsVertexTextures: function supportsVertexTextures() {
      console.warn('THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.')
      return this.capabilities.vertexTextures
    },
    supportsInstancedArrays: function supportsInstancedArrays() {
      console.warn("THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( 'ANGLE_instanced_arrays' ).")
      return this.extensions.get('ANGLE_instanced_arrays')
    },
    enableScissorTest: function enableScissorTest(boolean) {
      console.warn('THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().')
      this.setScissorTest(boolean)
    },
    initMaterial: function initMaterial() {
      console.warn('THREE.WebGLRenderer: .initMaterial() has been removed.')
    },
    addPrePlugin: function addPrePlugin() {
      console.warn('THREE.WebGLRenderer: .addPrePlugin() has been removed.')
    },
    addPostPlugin: function addPostPlugin() {
      console.warn('THREE.WebGLRenderer: .addPostPlugin() has been removed.')
    },
    updateShadowMap: function updateShadowMap() {
      console.warn('THREE.WebGLRenderer: .updateShadowMap() has been removed.')
    },
    setFaceCulling: function setFaceCulling() {
      console.warn('THREE.WebGLRenderer: .setFaceCulling() has been removed.')
    },
    allocTextureUnit: function allocTextureUnit() {
      console.warn('THREE.WebGLRenderer: .allocTextureUnit() has been removed.')
    },
    setTexture: function setTexture() {
      console.warn('THREE.WebGLRenderer: .setTexture() has been removed.')
    },
    setTexture2D: function setTexture2D() {
      console.warn('THREE.WebGLRenderer: .setTexture2D() has been removed.')
    },
    setTextureCube: function setTextureCube() {
      console.warn('THREE.WebGLRenderer: .setTextureCube() has been removed.')
    },
    getActiveMipMapLevel: function getActiveMipMapLevel() {
      console.warn('THREE.WebGLRenderer: .getActiveMipMapLevel() is now .getActiveMipmapLevel().')
      return this.getActiveMipmapLevel()
    }
  })
  Object.defineProperties(WebGLRenderer.prototype, {
    shadowMapEnabled: {
      get: function get() {
        return this.shadowMap.enabled
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.')
        this.shadowMap.enabled = value
      }
    },
    shadowMapType: {
      get: function get() {
        return this.shadowMap.type
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.')
        this.shadowMap.type = value
      }
    },
    shadowMapCullFace: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.')
        return undefined
      },
      set: function set() /* value */
      {
        console.warn('THREE.WebGLRenderer: .shadowMapCullFace has been removed. Set Material.shadowSide instead.')
      }
    },
    context: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .context has been removed. Use .getContext() instead.')
        return this.getContext()
      }
    },
    vr: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .vr has been renamed to .xr')
        return this.xr
      }
    },
    gammaInput: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.')
        return false
      },
      set: function set() {
        console.warn('THREE.WebGLRenderer: .gammaInput has been removed. Set the encoding for textures via Texture.encoding instead.')
      }
    },
    gammaOutput: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead.')
        return false
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderer: .gammaOutput has been removed. Set WebGLRenderer.outputEncoding instead.')
        this.outputEncoding = value === true ? sRGBEncoding : LinearEncoding
      }
    },
    toneMappingWhitePoint: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.')
        return 1.0
      },
      set: function set() {
        console.warn('THREE.WebGLRenderer: .toneMappingWhitePoint has been removed.')
      }
    }
  })
  Object.defineProperties(WebGLShadowMap.prototype, {
    cullFace: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.')
        return undefined
      },
      set: function set() /* cullFace */
      {
        console.warn('THREE.WebGLRenderer: .shadowMap.cullFace has been removed. Set Material.shadowSide instead.')
      }
    },
    renderReverseSided: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.')
        return undefined
      },
      set: function set() {
        console.warn('THREE.WebGLRenderer: .shadowMap.renderReverseSided has been removed. Set Material.shadowSide instead.')
      }
    },
    renderSingleSided: {
      get: function get() {
        console.warn('THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.')
        return undefined
      },
      set: function set() {
        console.warn('THREE.WebGLRenderer: .shadowMap.renderSingleSided has been removed. Set Material.shadowSide instead.')
      }
    }
  })
  function WebGLRenderTargetCube(width, height, options) {
    console.warn('THREE.WebGLRenderTargetCube( width, height, options ) is now WebGLCubeRenderTarget( size, options ).')
    return new WebGLCubeRenderTarget(width, options)
  } //

  Object.defineProperties(WebGLRenderTarget.prototype, {
    wrapS: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.')
        return this.texture.wrapS
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.')
        this.texture.wrapS = value
      }
    },
    wrapT: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.')
        return this.texture.wrapT
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.')
        this.texture.wrapT = value
      }
    },
    magFilter: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.')
        return this.texture.magFilter
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.')
        this.texture.magFilter = value
      }
    },
    minFilter: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.')
        return this.texture.minFilter
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.')
        this.texture.minFilter = value
      }
    },
    anisotropy: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.')
        return this.texture.anisotropy
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.')
        this.texture.anisotropy = value
      }
    },
    offset: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .offset is now .texture.offset.')
        return this.texture.offset
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .offset is now .texture.offset.')
        this.texture.offset = value
      }
    },
    repeat: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .repeat is now .texture.repeat.')
        return this.texture.repeat
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .repeat is now .texture.repeat.')
        this.texture.repeat = value
      }
    },
    format: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .format is now .texture.format.')
        return this.texture.format
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .format is now .texture.format.')
        this.texture.format = value
      }
    },
    type: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .type is now .texture.type.')
        return this.texture.type
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .type is now .texture.type.')
        this.texture.type = value
      }
    },
    generateMipmaps: {
      get: function get() {
        console.warn('THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.')
        return this.texture.generateMipmaps
      },
      set: function set(value) {
        console.warn('THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.')
        this.texture.generateMipmaps = value
      }
    }
  }) //

  Object.defineProperties(Audio.prototype, {
    load: {
      value: function value(file) {
        console.warn('THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.')
        var scope = this
        var audioLoader = new AudioLoader()
        audioLoader.load(file, function (buffer) {
          scope.setBuffer(buffer)
        })
        return this
      }
    },
    startTime: {
      set: function set() {
        console.warn('THREE.Audio: .startTime is now .play( delay ).')
      }
    }
  })

  AudioAnalyser.prototype.getData = function () {
    console.warn('THREE.AudioAnalyser: .getData() is now .getFrequencyData().')
    return this.getFrequencyData()
  } //

  CubeCamera.prototype.updateCubeMap = function (renderer, scene) {
    console.warn('THREE.CubeCamera: .updateCubeMap() is now .update().')
    return this.update(renderer, scene)
  }

  CubeCamera.prototype.clear = function (renderer, color, depth, stencil) {
    console.warn('THREE.CubeCamera: .clear() is now .renderTarget.clear().')
    return this.renderTarget.clear(renderer, color, depth, stencil)
  } //

  var GeometryUtils = {
    merge: function merge(geometry1, geometry2, materialIndexOffset) {
      console.warn('THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.')
      var matrix

      if (geometry2.isMesh) {
        geometry2.matrixAutoUpdate && geometry2.updateMatrix()
        matrix = geometry2.matrix
        geometry2 = geometry2.geometry
      }

      geometry1.merge(geometry2, matrix, materialIndexOffset)
    },
    center: function center(geometry) {
      console.warn('THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.')
      return geometry.center()
    }
  }
  ImageUtils.crossOrigin = undefined

  ImageUtils.loadTexture = function (url, mapping, onLoad, onError) {
    console.warn('THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.')
    var loader = new TextureLoader()
    loader.setCrossOrigin(this.crossOrigin)
    var texture = loader.load(url, onLoad, undefined, onError)
    if (mapping) texture.mapping = mapping
    return texture
  }

  ImageUtils.loadTextureCube = function (urls, mapping, onLoad, onError) {
    console.warn('THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.')
    var loader = new CubeTextureLoader()
    loader.setCrossOrigin(this.crossOrigin)
    var texture = loader.load(urls, onLoad, undefined, onError)
    if (mapping) texture.mapping = mapping
    return texture
  }

  ImageUtils.loadCompressedTexture = function () {
    console.error('THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.')
  }

  ImageUtils.loadCompressedTextureCube = function () {
    console.error('THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.')
  } //

  function CanvasRenderer() {
    console.error('THREE.CanvasRenderer has been removed')
  } //

  function JSONLoader() {
    console.error('THREE.JSONLoader has been removed.')
  } //

  var SceneUtils = {
    createMultiMaterialObject: function createMultiMaterialObject() /* geometry, materials */
    {
      console.error('THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js')
    },
    detach: function detach() /* child, parent, scene */
    {
      console.error('THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js')
    },
    attach: function attach() /* child, scene, parent */
    {
      console.error('THREE.SceneUtils has been moved to /examples/jsm/utils/SceneUtils.js')
    }
  } //

  function LensFlare() {
    console.error('THREE.LensFlare has been moved to /examples/jsm/objects/Lensflare.js')
  }

  if (typeof __THREE_DEVTOOLS__ !== 'undefined') {
    /* eslint-disable no-undef */
    __THREE_DEVTOOLS__.dispatchEvent(
      new CustomEvent('register', {
        detail: {
          revision: REVISION
        }
      })
    )
    /* eslint-enable no-undef */
  }

  exports.ACESFilmicToneMapping = ACESFilmicToneMapping
  exports.AddEquation = AddEquation
  exports.AddOperation = AddOperation
  exports.AdditiveAnimationBlendMode = AdditiveAnimationBlendMode
  exports.AdditiveBlending = AdditiveBlending
  exports.AlphaFormat = AlphaFormat
  exports.AlwaysDepth = AlwaysDepth
  exports.AlwaysStencilFunc = AlwaysStencilFunc
  exports.AmbientLight = AmbientLight
  exports.AmbientLightProbe = AmbientLightProbe
  exports.AnimationClip = AnimationClip
  exports.AnimationLoader = AnimationLoader
  exports.AnimationMixer = AnimationMixer
  exports.AnimationObjectGroup = AnimationObjectGroup
  exports.AnimationUtils = AnimationUtils
  exports.ArcCurve = ArcCurve
  exports.ArrayCamera = ArrayCamera
  exports.ArrowHelper = ArrowHelper
  exports.Audio = Audio
  exports.AudioAnalyser = AudioAnalyser
  exports.AudioContext = AudioContext
  exports.AudioListener = AudioListener
  exports.AudioLoader = AudioLoader
  exports.AxesHelper = AxesHelper
  exports.AxisHelper = AxisHelper
  exports.BackSide = BackSide
  exports.BasicDepthPacking = BasicDepthPacking
  exports.BasicShadowMap = BasicShadowMap
  exports.BinaryTextureLoader = BinaryTextureLoader
  exports.Bone = Bone
  exports.BooleanKeyframeTrack = BooleanKeyframeTrack
  exports.BoundingBoxHelper = BoundingBoxHelper
  exports.Box2 = Box2
  exports.Box3 = Box3
  exports.Box3Helper = Box3Helper
  exports.BoxBufferGeometry = BoxBufferGeometry
  exports.BoxGeometry = BoxGeometry
  exports.BoxHelper = BoxHelper
  exports.BufferAttribute = BufferAttribute
  exports.BufferGeometry = BufferGeometry
  exports.BufferGeometryLoader = BufferGeometryLoader
  exports.ByteType = ByteType
  exports.Cache = Cache
  exports.Camera = Camera
  exports.CameraHelper = CameraHelper
  exports.CanvasRenderer = CanvasRenderer
  exports.CanvasTexture = CanvasTexture
  exports.CatmullRomCurve3 = CatmullRomCurve3
  exports.CineonToneMapping = CineonToneMapping
  exports.CircleBufferGeometry = CircleBufferGeometry
  exports.CircleGeometry = CircleGeometry
  exports.ClampToEdgeWrapping = ClampToEdgeWrapping
  exports.Clock = Clock
  exports.ClosedSplineCurve3 = ClosedSplineCurve3
  exports.Color = Color
  exports.ColorKeyframeTrack = ColorKeyframeTrack
  exports.CompressedTexture = CompressedTexture
  exports.CompressedTextureLoader = CompressedTextureLoader
  exports.ConeBufferGeometry = ConeBufferGeometry
  exports.ConeGeometry = ConeGeometry
  exports.CubeCamera = CubeCamera
  exports.CubeGeometry = BoxGeometry
  exports.CubeReflectionMapping = CubeReflectionMapping
  exports.CubeRefractionMapping = CubeRefractionMapping
  exports.CubeTexture = CubeTexture
  exports.CubeTextureLoader = CubeTextureLoader
  exports.CubeUVReflectionMapping = CubeUVReflectionMapping
  exports.CubeUVRefractionMapping = CubeUVRefractionMapping
  exports.CubicBezierCurve = CubicBezierCurve
  exports.CubicBezierCurve3 = CubicBezierCurve3
  exports.CubicInterpolant = CubicInterpolant
  exports.CullFaceBack = CullFaceBack
  exports.CullFaceFront = CullFaceFront
  exports.CullFaceFrontBack = CullFaceFrontBack
  exports.CullFaceNone = CullFaceNone
  exports.Curve = Curve
  exports.CurvePath = CurvePath
  exports.CustomBlending = CustomBlending
  exports.CustomToneMapping = CustomToneMapping
  exports.CylinderBufferGeometry = CylinderBufferGeometry
  exports.CylinderGeometry = CylinderGeometry
  exports.Cylindrical = Cylindrical
  exports.DataTexture = DataTexture
  exports.DataTexture2DArray = DataTexture2DArray
  exports.DataTexture3D = DataTexture3D
  exports.DataTextureLoader = DataTextureLoader
  exports.DataUtils = DataUtils
  exports.DecrementStencilOp = DecrementStencilOp
  exports.DecrementWrapStencilOp = DecrementWrapStencilOp
  exports.DefaultLoadingManager = DefaultLoadingManager
  exports.DepthFormat = DepthFormat
  exports.DepthStencilFormat = DepthStencilFormat
  exports.DepthTexture = DepthTexture
  exports.DirectionalLight = DirectionalLight
  exports.DirectionalLightHelper = DirectionalLightHelper
  exports.DiscreteInterpolant = DiscreteInterpolant
  exports.DodecahedronBufferGeometry = DodecahedronBufferGeometry
  exports.DodecahedronGeometry = DodecahedronGeometry
  exports.DoubleSide = DoubleSide
  exports.DstAlphaFactor = DstAlphaFactor
  exports.DstColorFactor = DstColorFactor
  exports.DynamicBufferAttribute = DynamicBufferAttribute
  exports.DynamicCopyUsage = DynamicCopyUsage
  exports.DynamicDrawUsage = DynamicDrawUsage
  exports.DynamicReadUsage = DynamicReadUsage
  exports.EdgesGeometry = EdgesGeometry
  exports.EdgesHelper = EdgesHelper
  exports.EllipseCurve = EllipseCurve
  exports.EqualDepth = EqualDepth
  exports.EqualStencilFunc = EqualStencilFunc
  exports.EquirectangularReflectionMapping = EquirectangularReflectionMapping
  exports.EquirectangularRefractionMapping = EquirectangularRefractionMapping
  exports.Euler = Euler
  exports.EventDispatcher = EventDispatcher
  exports.ExtrudeBufferGeometry = ExtrudeBufferGeometry
  exports.ExtrudeGeometry = ExtrudeGeometry
  exports.Face3 = Face3
  exports.Face4 = Face4
  exports.FaceColors = FaceColors
  exports.FileLoader = FileLoader
  exports.FlatShading = FlatShading
  exports.Float16BufferAttribute = Float16BufferAttribute
  exports.Float32Attribute = Float32Attribute
  exports.Float32BufferAttribute = Float32BufferAttribute
  exports.Float64Attribute = Float64Attribute
  exports.Float64BufferAttribute = Float64BufferAttribute
  exports.FloatType = FloatType
  exports.Fog = Fog
  exports.FogExp2 = FogExp2
  exports.Font = Font
  exports.FontLoader = FontLoader
  exports.FrontSide = FrontSide
  exports.Frustum = Frustum
  exports.GLBufferAttribute = GLBufferAttribute
  exports.GLSL1 = GLSL1
  exports.GLSL3 = GLSL3
  exports.GammaEncoding = GammaEncoding
  exports.Geometry = Geometry
  exports.GeometryUtils = GeometryUtils
  exports.GreaterDepth = GreaterDepth
  exports.GreaterEqualDepth = GreaterEqualDepth
  exports.GreaterEqualStencilFunc = GreaterEqualStencilFunc
  exports.GreaterStencilFunc = GreaterStencilFunc
  exports.GridHelper = GridHelper
  exports.Group = Group
  exports.HalfFloatType = HalfFloatType
  exports.HemisphereLight = HemisphereLight
  exports.HemisphereLightHelper = HemisphereLightHelper
  exports.HemisphereLightProbe = HemisphereLightProbe
  exports.IcosahedronBufferGeometry = IcosahedronBufferGeometry
  exports.IcosahedronGeometry = IcosahedronGeometry
  exports.ImageBitmapLoader = ImageBitmapLoader
  exports.ImageLoader = ImageLoader
  exports.ImageUtils = ImageUtils
  exports.ImmediateRenderObject = ImmediateRenderObject
  exports.IncrementStencilOp = IncrementStencilOp
  exports.IncrementWrapStencilOp = IncrementWrapStencilOp
  exports.InstancedBufferAttribute = InstancedBufferAttribute
  exports.InstancedBufferGeometry = InstancedBufferGeometry
  exports.InstancedInterleavedBuffer = InstancedInterleavedBuffer
  exports.InstancedMesh = InstancedMesh
  exports.Int16Attribute = Int16Attribute
  exports.Int16BufferAttribute = Int16BufferAttribute
  exports.Int32Attribute = Int32Attribute
  exports.Int32BufferAttribute = Int32BufferAttribute
  exports.Int8Attribute = Int8Attribute
  exports.Int8BufferAttribute = Int8BufferAttribute
  exports.IntType = IntType
  exports.InterleavedBuffer = InterleavedBuffer
  exports.InterleavedBufferAttribute = InterleavedBufferAttribute
  exports.Interpolant = Interpolant
  exports.InterpolateDiscrete = InterpolateDiscrete
  exports.InterpolateLinear = InterpolateLinear
  exports.InterpolateSmooth = InterpolateSmooth
  exports.InvertStencilOp = InvertStencilOp
  exports.JSONLoader = JSONLoader
  exports.KeepStencilOp = KeepStencilOp
  exports.KeyframeTrack = KeyframeTrack
  exports.LOD = LOD
  exports.LatheBufferGeometry = LatheBufferGeometry
  exports.LatheGeometry = LatheGeometry
  exports.Layers = Layers
  exports.LensFlare = LensFlare
  exports.LessDepth = LessDepth
  exports.LessEqualDepth = LessEqualDepth
  exports.LessEqualStencilFunc = LessEqualStencilFunc
  exports.LessStencilFunc = LessStencilFunc
  exports.Light = Light
  exports.LightProbe = LightProbe
  exports.Line = Line
  exports.Line3 = Line3
  exports.LineBasicMaterial = LineBasicMaterial
  exports.LineCurve = LineCurve
  exports.LineCurve3 = LineCurve3
  exports.LineDashedMaterial = LineDashedMaterial
  exports.LineLoop = LineLoop
  exports.LinePieces = LinePieces
  exports.LineSegments = LineSegments
  exports.LineStrip = LineStrip
  exports.LinearEncoding = LinearEncoding
  exports.LinearFilter = LinearFilter
  exports.LinearInterpolant = LinearInterpolant
  exports.LinearMipMapLinearFilter = LinearMipMapLinearFilter
  exports.LinearMipMapNearestFilter = LinearMipMapNearestFilter
  exports.LinearMipmapLinearFilter = LinearMipmapLinearFilter
  exports.LinearMipmapNearestFilter = LinearMipmapNearestFilter
  exports.LinearToneMapping = LinearToneMapping
  exports.Loader = Loader
  exports.LoaderUtils = LoaderUtils
  exports.LoadingManager = LoadingManager
  exports.LogLuvEncoding = LogLuvEncoding
  exports.LoopOnce = LoopOnce
  exports.LoopPingPong = LoopPingPong
  exports.LoopRepeat = LoopRepeat
  exports.LuminanceAlphaFormat = LuminanceAlphaFormat
  exports.LuminanceFormat = LuminanceFormat
  exports.MOUSE = MOUSE
  exports.Material = Material
  exports.MaterialLoader = MaterialLoader
  exports.Math = MathUtils
  exports.MathUtils = MathUtils
  exports.Matrix3 = Matrix3
  exports.Matrix4 = Matrix4
  exports.MaxEquation = MaxEquation
  exports.Mesh = Mesh
  exports.MeshBasicMaterial = MeshBasicMaterial
  exports.MeshDepthMaterial = MeshDepthMaterial
  exports.MeshDistanceMaterial = MeshDistanceMaterial
  exports.MeshFaceMaterial = MeshFaceMaterial
  exports.MeshLambertMaterial = MeshLambertMaterial
  exports.MeshMatcapMaterial = MeshMatcapMaterial
  exports.MeshNormalMaterial = MeshNormalMaterial
  exports.MeshPhongMaterial = MeshPhongMaterial
  exports.MeshPhysicalMaterial = MeshPhysicalMaterial
  exports.MeshStandardMaterial = MeshStandardMaterial
  exports.MeshToonMaterial = MeshToonMaterial
  exports.MinEquation = MinEquation
  exports.MirroredRepeatWrapping = MirroredRepeatWrapping
  exports.MixOperation = MixOperation
  exports.MultiMaterial = MultiMaterial
  exports.MultiplyBlending = MultiplyBlending
  exports.MultiplyOperation = MultiplyOperation
  exports.NearestFilter = NearestFilter
  exports.NearestMipMapLinearFilter = NearestMipMapLinearFilter
  exports.NearestMipMapNearestFilter = NearestMipMapNearestFilter
  exports.NearestMipmapLinearFilter = NearestMipmapLinearFilter
  exports.NearestMipmapNearestFilter = NearestMipmapNearestFilter
  exports.NeverDepth = NeverDepth
  exports.NeverStencilFunc = NeverStencilFunc
  exports.NoBlending = NoBlending
  exports.NoColors = NoColors
  exports.NoToneMapping = NoToneMapping
  exports.NormalAnimationBlendMode = NormalAnimationBlendMode
  exports.NormalBlending = NormalBlending
  exports.NotEqualDepth = NotEqualDepth
  exports.NotEqualStencilFunc = NotEqualStencilFunc
  exports.NumberKeyframeTrack = NumberKeyframeTrack
  exports.Object3D = Object3D
  exports.ObjectLoader = ObjectLoader
  exports.ObjectSpaceNormalMap = ObjectSpaceNormalMap
  exports.OctahedronBufferGeometry = OctahedronBufferGeometry
  exports.OctahedronGeometry = OctahedronGeometry
  exports.OneFactor = OneFactor
  exports.OneMinusDstAlphaFactor = OneMinusDstAlphaFactor
  exports.OneMinusDstColorFactor = OneMinusDstColorFactor
  exports.OneMinusSrcAlphaFactor = OneMinusSrcAlphaFactor
  exports.OneMinusSrcColorFactor = OneMinusSrcColorFactor
  exports.OrthographicCamera = OrthographicCamera
  exports.PCFShadowMap = PCFShadowMap
  exports.PCFSoftShadowMap = PCFSoftShadowMap
  exports.PMREMGenerator = PMREMGenerator
  exports.ParametricBufferGeometry = ParametricBufferGeometry
  exports.ParametricGeometry = ParametricGeometry
  exports.Particle = Particle
  exports.ParticleBasicMaterial = ParticleBasicMaterial
  exports.ParticleSystem = ParticleSystem
  exports.ParticleSystemMaterial = ParticleSystemMaterial
  exports.Path = Path
  exports.PerspectiveCamera = PerspectiveCamera
  exports.Plane = Plane
  exports.PlaneBufferGeometry = PlaneBufferGeometry
  exports.PlaneGeometry = PlaneGeometry
  exports.PlaneHelper = PlaneHelper
  exports.PointCloud = PointCloud
  exports.PointCloudMaterial = PointCloudMaterial
  exports.PointLight = PointLight
  exports.PointLightHelper = PointLightHelper
  exports.Points = Points
  exports.PointsMaterial = PointsMaterial
  exports.PolarGridHelper = PolarGridHelper
  exports.PolyhedronBufferGeometry = PolyhedronBufferGeometry
  exports.PolyhedronGeometry = PolyhedronGeometry
  exports.PositionalAudio = PositionalAudio
  exports.PropertyBinding = PropertyBinding
  exports.PropertyMixer = PropertyMixer
  exports.QuadraticBezierCurve = QuadraticBezierCurve
  exports.QuadraticBezierCurve3 = QuadraticBezierCurve3
  exports.Quaternion = Quaternion
  exports.QuaternionKeyframeTrack = QuaternionKeyframeTrack
  exports.QuaternionLinearInterpolant = QuaternionLinearInterpolant
  exports.REVISION = REVISION
  exports.RGBADepthPacking = RGBADepthPacking
  exports.RGBAFormat = RGBAFormat
  exports.RGBAIntegerFormat = RGBAIntegerFormat
  exports.RGBA_ASTC_10x10_Format = RGBA_ASTC_10x10_Format
  exports.RGBA_ASTC_10x5_Format = RGBA_ASTC_10x5_Format
  exports.RGBA_ASTC_10x6_Format = RGBA_ASTC_10x6_Format
  exports.RGBA_ASTC_10x8_Format = RGBA_ASTC_10x8_Format
  exports.RGBA_ASTC_12x10_Format = RGBA_ASTC_12x10_Format
  exports.RGBA_ASTC_12x12_Format = RGBA_ASTC_12x12_Format
  exports.RGBA_ASTC_4x4_Format = RGBA_ASTC_4x4_Format
  exports.RGBA_ASTC_5x4_Format = RGBA_ASTC_5x4_Format
  exports.RGBA_ASTC_5x5_Format = RGBA_ASTC_5x5_Format
  exports.RGBA_ASTC_6x5_Format = RGBA_ASTC_6x5_Format
  exports.RGBA_ASTC_6x6_Format = RGBA_ASTC_6x6_Format
  exports.RGBA_ASTC_8x5_Format = RGBA_ASTC_8x5_Format
  exports.RGBA_ASTC_8x6_Format = RGBA_ASTC_8x6_Format
  exports.RGBA_ASTC_8x8_Format = RGBA_ASTC_8x8_Format
  exports.RGBA_BPTC_Format = RGBA_BPTC_Format
  exports.RGBA_ETC2_EAC_Format = RGBA_ETC2_EAC_Format
  exports.RGBA_PVRTC_2BPPV1_Format = RGBA_PVRTC_2BPPV1_Format
  exports.RGBA_PVRTC_4BPPV1_Format = RGBA_PVRTC_4BPPV1_Format
  exports.RGBA_S3TC_DXT1_Format = RGBA_S3TC_DXT1_Format
  exports.RGBA_S3TC_DXT3_Format = RGBA_S3TC_DXT3_Format
  exports.RGBA_S3TC_DXT5_Format = RGBA_S3TC_DXT5_Format
  exports.RGBDEncoding = RGBDEncoding
  exports.RGBEEncoding = RGBEEncoding
  exports.RGBEFormat = RGBEFormat
  exports.RGBFormat = RGBFormat
  exports.RGBIntegerFormat = RGBIntegerFormat
  exports.RGBM16Encoding = RGBM16Encoding
  exports.RGBM7Encoding = RGBM7Encoding
  exports.RGB_ETC1_Format = RGB_ETC1_Format
  exports.RGB_ETC2_Format = RGB_ETC2_Format
  exports.RGB_PVRTC_2BPPV1_Format = RGB_PVRTC_2BPPV1_Format
  exports.RGB_PVRTC_4BPPV1_Format = RGB_PVRTC_4BPPV1_Format
  exports.RGB_S3TC_DXT1_Format = RGB_S3TC_DXT1_Format
  exports.RGFormat = RGFormat
  exports.RGIntegerFormat = RGIntegerFormat
  exports.RawShaderMaterial = RawShaderMaterial
  exports.Ray = Ray
  exports.Raycaster = Raycaster
  exports.RectAreaLight = RectAreaLight
  exports.RedFormat = RedFormat
  exports.RedIntegerFormat = RedIntegerFormat
  exports.ReinhardToneMapping = ReinhardToneMapping
  exports.RepeatWrapping = RepeatWrapping
  exports.ReplaceStencilOp = ReplaceStencilOp
  exports.ReverseSubtractEquation = ReverseSubtractEquation
  exports.RingBufferGeometry = RingBufferGeometry
  exports.RingGeometry = RingGeometry
  exports.SRGB8_ALPHA8_ASTC_10x10_Format = SRGB8_ALPHA8_ASTC_10x10_Format
  exports.SRGB8_ALPHA8_ASTC_10x5_Format = SRGB8_ALPHA8_ASTC_10x5_Format
  exports.SRGB8_ALPHA8_ASTC_10x6_Format = SRGB8_ALPHA8_ASTC_10x6_Format
  exports.SRGB8_ALPHA8_ASTC_10x8_Format = SRGB8_ALPHA8_ASTC_10x8_Format
  exports.SRGB8_ALPHA8_ASTC_12x10_Format = SRGB8_ALPHA8_ASTC_12x10_Format
  exports.SRGB8_ALPHA8_ASTC_12x12_Format = SRGB8_ALPHA8_ASTC_12x12_Format
  exports.SRGB8_ALPHA8_ASTC_4x4_Format = SRGB8_ALPHA8_ASTC_4x4_Format
  exports.SRGB8_ALPHA8_ASTC_5x4_Format = SRGB8_ALPHA8_ASTC_5x4_Format
  exports.SRGB8_ALPHA8_ASTC_5x5_Format = SRGB8_ALPHA8_ASTC_5x5_Format
  exports.SRGB8_ALPHA8_ASTC_6x5_Format = SRGB8_ALPHA8_ASTC_6x5_Format
  exports.SRGB8_ALPHA8_ASTC_6x6_Format = SRGB8_ALPHA8_ASTC_6x6_Format
  exports.SRGB8_ALPHA8_ASTC_8x5_Format = SRGB8_ALPHA8_ASTC_8x5_Format
  exports.SRGB8_ALPHA8_ASTC_8x6_Format = SRGB8_ALPHA8_ASTC_8x6_Format
  exports.SRGB8_ALPHA8_ASTC_8x8_Format = SRGB8_ALPHA8_ASTC_8x8_Format
  exports.Scene = Scene
  exports.SceneUtils = SceneUtils
  exports.ShaderChunk = ShaderChunk
  exports.ShaderLib = ShaderLib
  exports.ShaderMaterial = ShaderMaterial
  exports.ShadowMaterial = ShadowMaterial
  exports.Shape = Shape
  exports.ShapeBufferGeometry = ShapeBufferGeometry
  exports.ShapeGeometry = ShapeGeometry
  exports.ShapePath = ShapePath
  exports.ShapeUtils = ShapeUtils
  exports.ShortType = ShortType
  exports.Skeleton = Skeleton
  exports.SkeletonHelper = SkeletonHelper
  exports.SkinnedMesh = SkinnedMesh
  exports.SmoothShading = SmoothShading
  exports.Sphere = Sphere
  exports.SphereBufferGeometry = SphereBufferGeometry
  exports.SphereGeometry = SphereGeometry
  exports.Spherical = Spherical
  exports.SphericalHarmonics3 = SphericalHarmonics3
  exports.Spline = Spline
  exports.SplineCurve = SplineCurve
  exports.SplineCurve3 = SplineCurve3
  exports.SpotLight = SpotLight
  exports.SpotLightHelper = SpotLightHelper
  exports.Sprite = Sprite
  exports.SpriteMaterial = SpriteMaterial
  exports.SrcAlphaFactor = SrcAlphaFactor
  exports.SrcAlphaSaturateFactor = SrcAlphaSaturateFactor
  exports.SrcColorFactor = SrcColorFactor
  exports.StaticCopyUsage = StaticCopyUsage
  exports.StaticDrawUsage = StaticDrawUsage
  exports.StaticReadUsage = StaticReadUsage
  exports.StereoCamera = StereoCamera
  exports.StreamCopyUsage = StreamCopyUsage
  exports.StreamDrawUsage = StreamDrawUsage
  exports.StreamReadUsage = StreamReadUsage
  exports.StringKeyframeTrack = StringKeyframeTrack
  exports.SubtractEquation = SubtractEquation
  exports.SubtractiveBlending = SubtractiveBlending
  exports.TOUCH = TOUCH
  exports.TangentSpaceNormalMap = TangentSpaceNormalMap
  exports.TetrahedronBufferGeometry = TetrahedronBufferGeometry
  exports.TetrahedronGeometry = TetrahedronGeometry
  exports.TextBufferGeometry = TextBufferGeometry
  exports.TextGeometry = TextGeometry
  exports.Texture = Texture
  exports.TextureLoader = TextureLoader
  exports.TorusBufferGeometry = TorusBufferGeometry
  exports.TorusGeometry = TorusGeometry
  exports.TorusKnotBufferGeometry = TorusKnotBufferGeometry
  exports.TorusKnotGeometry = TorusKnotGeometry
  exports.Triangle = Triangle
  exports.TriangleFanDrawMode = TriangleFanDrawMode
  exports.TriangleStripDrawMode = TriangleStripDrawMode
  exports.TrianglesDrawMode = TrianglesDrawMode
  exports.TubeBufferGeometry = TubeBufferGeometry
  exports.TubeGeometry = TubeGeometry
  exports.UVMapping = UVMapping
  exports.Uint16Attribute = Uint16Attribute
  exports.Uint16BufferAttribute = Uint16BufferAttribute
  exports.Uint32Attribute = Uint32Attribute
  exports.Uint32BufferAttribute = Uint32BufferAttribute
  exports.Uint8Attribute = Uint8Attribute
  exports.Uint8BufferAttribute = Uint8BufferAttribute
  exports.Uint8ClampedAttribute = Uint8ClampedAttribute
  exports.Uint8ClampedBufferAttribute = Uint8ClampedBufferAttribute
  exports.Uniform = Uniform
  exports.UniformsLib = UniformsLib
  exports.UniformsUtils = UniformsUtils
  exports.UnsignedByteType = UnsignedByteType
  exports.UnsignedInt248Type = UnsignedInt248Type
  exports.UnsignedIntType = UnsignedIntType
  exports.UnsignedShort4444Type = UnsignedShort4444Type
  exports.UnsignedShort5551Type = UnsignedShort5551Type
  exports.UnsignedShort565Type = UnsignedShort565Type
  exports.UnsignedShortType = UnsignedShortType
  exports.VSMShadowMap = VSMShadowMap
  exports.Vector2 = Vector2
  exports.Vector3 = Vector3
  exports.Vector4 = Vector4
  exports.VectorKeyframeTrack = VectorKeyframeTrack
  exports.Vertex = Vertex
  exports.VertexColors = VertexColors
  exports.VideoTexture = VideoTexture
  exports.WebGL1Renderer = WebGL1Renderer
  exports.WebGLCubeRenderTarget = WebGLCubeRenderTarget
  exports.WebGLMultisampleRenderTarget = WebGLMultisampleRenderTarget
  exports.WebGLRenderTarget = WebGLRenderTarget
  exports.WebGLRenderTargetCube = WebGLRenderTargetCube
  exports.WebGLRenderer = WebGLRenderer
  exports.WebGLUtils = WebGLUtils
  exports.WireframeGeometry = WireframeGeometry
  exports.WireframeHelper = WireframeHelper
  exports.WrapAroundEnding = WrapAroundEnding
  exports.XHRLoader = XHRLoader
  exports.ZeroCurvatureEnding = ZeroCurvatureEnding
  exports.ZeroFactor = ZeroFactor
  exports.ZeroSlopeEnding = ZeroSlopeEnding
  exports.ZeroStencilOp = ZeroStencilOp
  exports.sRGBEncoding = sRGBEncoding

  Object.defineProperty(exports, '__esModule', { value: true })
})

/**
 * @author mrdoob / http://mrdoob.com/
 */

THREE.CSS2DObject = function (element) {
  THREE.Object3D.call(this)

  this.element = element
  this.element.style.position = 'absolute'

  // this.addEventListener( 'removed', function () {

  // 	if ( this.element.parentNode !== null ) {

  // 		this.element.parentNode.removeChild( this.element );

  // 	}

  // } );
}

THREE.CSS2DObject.prototype = Object.create(THREE.Object3D.prototype)
THREE.CSS2DObject.prototype.constructor = THREE.CSS2DObject

//

THREE.CSS2DRenderer = function () {
  //console.log( 'THREE.CSS2DRenderer', THREE.REVISION );

  var _width, _height
  var _widthHalf, _heightHalf
  var perc_H = '-50%' //自定义横向和纵向移动百分比
  var perc_V = '-99%'

  var vector = new THREE.Vector3()
  var viewMatrix = new THREE.Matrix4()
  var viewProjectionMatrix = new THREE.Matrix4()

  var cache = {
    objects: new WeakMap()
  }

  var domElement = document.createElement('div')
  domElement.style.overflow = 'hidden'
  this.domElement = domElement

  this.getSize = function () {
    return {
      width: _width,
      height: _height
    }
  }

  this.setSize = function (width, height, perc_h = '-50%') {
    _width = width
    _height = height
    perc_H = perc_h
    _widthHalf = _width / 2
    _heightHalf = _height / 2

    domElement.style.width = width + 'px'
    domElement.style.height = height + 'px'
  }

  var renderObject = function (object, camera) {
    if (object instanceof THREE.CSS2DObject) {
      vector.setFromMatrixPosition(object.matrixWorld)
      vector.applyMatrix4(viewProjectionMatrix)

      var element = object.element
      var style = 'translate(' + perc_H + ',-100%) translate(' + (vector.x * _widthHalf + _widthHalf) + 'px,' + (-vector.y * _heightHalf + _heightHalf) + 'px)'

      element.style.WebkitTransform = style
      element.style.MozTransform = style
      element.style.oTransform = style
      element.style.transform = style
      element.style.display = object.visible && vector.z >= -1 && vector.z <= 1 ? '' : 'none'

      var objectData = {
        distanceToCameraSquared: getDistanceToSquared(camera, object)
      }

      cache.objects.set(object, objectData)

      if (element.parentNode !== domElement) {
        domElement.appendChild(element)
      }
    }

    for (var i = 0, l = object.children.length; i < l; i++) {
      renderObject(object.children[i], camera)
    }
  }

  var getDistanceToSquared = (function () {
    var a = new THREE.Vector3()
    var b = new THREE.Vector3()

    return function (object1, object2) {
      a.setFromMatrixPosition(object1.matrixWorld)
      b.setFromMatrixPosition(object2.matrixWorld)

      return a.distanceToSquared(b)
    }
  })()

  var filterAndFlatten = function (scene) {
    var result = []

    scene.traverse(function (object) {
      if (object instanceof THREE.CSS2DObject) result.push(object)
    })

    return result
  }

  var zOrder = function (scene) {
    var sorted = filterAndFlatten(scene).sort(function (a, b) {
      var distanceA = cache.objects.get(a).distanceToCameraSquared
      var distanceB = cache.objects.get(b).distanceToCameraSquared

      return distanceA - distanceB
    })

    var zMax = sorted.length

    for (var i = 0, l = sorted.length; i < l; i++) {
      sorted[i].element.style.zIndex = zMax - i
    }
  }

  this.render = function (scene, camera) {
    scene.updateMatrixWorld()

    if (camera.parent === null) camera.updateMatrixWorld()

    viewMatrix.copy(camera.matrixWorldInverse)
    viewProjectionMatrix.multiplyMatrices(camera.projectionMatrix, viewMatrix)

    renderObject(scene, camera)
    zOrder(scene)
  }
}

THREE.GLTFLoader = (function () {
  function GLTFLoader(manager) {
    THREE.Loader.call(this, manager)

    this.dracoLoader = null
    this.ddsLoader = null
    this.ktx2Loader = null
    this.meshoptDecoder = null

    this.pluginCallbacks = []

    this.register(function (parser) {
      return new GLTFMaterialsClearcoatExtension(parser)
    })

    this.register(function (parser) {
      return new GLTFTextureBasisUExtension(parser)
    })

    this.register(function (parser) {
      return new GLTFTextureWebPExtension(parser)
    })

    this.register(function (parser) {
      return new GLTFMaterialsTransmissionExtension(parser)
    })

    this.register(function (parser) {
      return new GLTFLightsExtension(parser)
    })

    this.register(function (parser) {
      return new GLTFMeshoptCompression(parser)
    })
  }

  GLTFLoader.prototype = Object.assign(Object.create(THREE.Loader.prototype), {
    constructor: GLTFLoader,

    load: function (url, onLoad, onProgress, onError) {
      var scope = this

      var resourcePath

      if (this.resourcePath !== '') {
        resourcePath = this.resourcePath
      } else if (this.path !== '') {
        resourcePath = this.path
      } else {
        resourcePath = THREE.LoaderUtils.extractUrlBase(url)
      }

      // Tells the LoadingManager to track an extra item, which resolves after
      // the model is fully loaded. This means the count of items loaded will
      // be incorrect, but ensures manager.onLoad() does not fire early.
      this.manager.itemStart(url)

      var _onError = function (e) {
        if (onError) {
          onError(e)
        } else {
          console.error(e)
        }

        scope.manager.itemError(url)
        scope.manager.itemEnd(url)
      }

      var loader = new THREE.FileLoader(this.manager)

      loader.setPath(this.path)
      loader.setResponseType('arraybuffer')
      loader.setRequestHeader(this.requestHeader)
      loader.setWithCredentials(this.withCredentials)

      loader.load(
        url,
        function (data) {
          try {
            scope.parse(
              data,
              resourcePath,
              function (gltf) {
                onLoad(gltf)

                scope.manager.itemEnd(url)
              },
              _onError
            )
          } catch (e) {
            _onError(e)
          }
        },
        onProgress,
        _onError
      )
    },

    setDRACOLoader: function (dracoLoader) {
      this.dracoLoader = dracoLoader
      return this
    },

    setDDSLoader: function (ddsLoader) {
      this.ddsLoader = ddsLoader
      return this
    },

    setKTX2Loader: function (ktx2Loader) {
      this.ktx2Loader = ktx2Loader
      return this
    },

    setMeshoptDecoder: function (meshoptDecoder) {
      this.meshoptDecoder = meshoptDecoder
      return this
    },

    register: function (callback) {
      if (this.pluginCallbacks.indexOf(callback) === -1) {
        this.pluginCallbacks.push(callback)
      }

      return this
    },

    unregister: function (callback) {
      if (this.pluginCallbacks.indexOf(callback) !== -1) {
        this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1)
      }

      return this
    },

    parse: function (data, path, onLoad, onError) {
      var content
      var extensions = {}
      var plugins = {}

      if (typeof data === 'string') {
        content = data
      } else {
        var magic = THREE.LoaderUtils.decodeText(new Uint8Array(data, 0, 4))

        if (magic === BINARY_EXTENSION_HEADER_MAGIC) {
          try {
            extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(data)
          } catch (error) {
            if (onError) onError(error)
            return
          }

          content = extensions[EXTENSIONS.KHR_BINARY_GLTF].content
        } else {
          content = THREE.LoaderUtils.decodeText(new Uint8Array(data))
        }
      }

      var json = JSON.parse(content)

      if (json.asset === undefined || json.asset.version[0] < 2) {
        if (onError) onError(new Error('THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.'))
        return
      }

      var parser = new GLTFParser(json, {
        path: path || this.resourcePath || '',
        crossOrigin: this.crossOrigin,
        manager: this.manager,
        ktx2Loader: this.ktx2Loader,
        meshoptDecoder: this.meshoptDecoder
      })

      parser.fileLoader.setRequestHeader(this.requestHeader)

      for (var i = 0; i < this.pluginCallbacks.length; i++) {
        var plugin = this.pluginCallbacks[i](parser)
        plugins[plugin.name] = plugin

        // Workaround to avoid determining as unknown extension
        // in addUnknownExtensionsToUserData().
        // Remove this workaround if we move all the existing
        // extension handlers to plugin system
        extensions[plugin.name] = true
      }

      if (json.extensionsUsed) {
        for (var i = 0; i < json.extensionsUsed.length; ++i) {
          var extensionName = json.extensionsUsed[i]
          var extensionsRequired = json.extensionsRequired || []

          switch (extensionName) {
            case EXTENSIONS.KHR_MATERIALS_UNLIT:
              extensions[extensionName] = new GLTFMaterialsUnlitExtension()
              break

            case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
              extensions[extensionName] = new GLTFMaterialsPbrSpecularGlossinessExtension()
              break

            case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
              extensions[extensionName] = new GLTFDracoMeshCompressionExtension(json, this.dracoLoader)
              break

            case EXTENSIONS.MSFT_TEXTURE_DDS:
              extensions[extensionName] = new GLTFTextureDDSExtension(this.ddsLoader)
              break

            case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
              extensions[extensionName] = new GLTFTextureTransformExtension()
              break

            case EXTENSIONS.KHR_MESH_QUANTIZATION:
              extensions[extensionName] = new GLTFMeshQuantizationExtension()
              break

            default:
              if (extensionsRequired.indexOf(extensionName) >= 0 && plugins[extensionName] === undefined) {
                console.warn('THREE.GLTFLoader: Unknown extension "' + extensionName + '".')
              }
          }
        }
      }

      parser.setExtensions(extensions)
      parser.setPlugins(plugins)
      parser.parse(onLoad, onError)
    }
  })

  /* GLTFREGISTRY */

  function GLTFRegistry() {
    var objects = {}

    return {
      get: function (key) {
        return objects[key]
      },

      add: function (key, object) {
        objects[key] = object
      },

      remove: function (key) {
        delete objects[key]
      },

      removeAll: function () {
        objects = {}
      }
    }
  }

  /*********************************/
  /********** EXTENSIONS ***********/
  /*********************************/

  var EXTENSIONS = {
    KHR_BINARY_GLTF: 'KHR_binary_glTF',
    KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
    KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
    KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
    KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
    KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
    KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
    KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
    KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
    KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
    EXT_TEXTURE_WEBP: 'EXT_texture_webp',
    EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',
    MSFT_TEXTURE_DDS: 'MSFT_texture_dds'
  }

  /**
   * DDS Texture Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_texture_dds
   *
   */
  function GLTFTextureDDSExtension(ddsLoader) {
    if (!ddsLoader) {
      throw new Error('THREE.GLTFLoader: Attempting to load .dds texture without importing THREE.DDSLoader')
    }

    this.name = EXTENSIONS.MSFT_TEXTURE_DDS
    this.ddsLoader = ddsLoader
  }

  /**
   * Punctual Lights Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
   */
  function GLTFLightsExtension(parser) {
    this.parser = parser
    this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL

    // Object3D instance caches
    this.cache = { refs: {}, uses: {} }
  }

  GLTFLightsExtension.prototype._markDefs = function () {
    var parser = this.parser
    var nodeDefs = this.parser.json.nodes || []

    for (var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
      var nodeDef = nodeDefs[nodeIndex]

      if (nodeDef.extensions && nodeDef.extensions[this.name] && nodeDef.extensions[this.name].light !== undefined) {
        parser._addNodeRef(this.cache, nodeDef.extensions[this.name].light)
      }
    }
  }

  GLTFLightsExtension.prototype._loadLight = function (lightIndex) {
    var parser = this.parser
    var cacheKey = 'light:' + lightIndex
    var dependency = parser.cache.get(cacheKey)

    if (dependency) return dependency

    var json = parser.json
    var extensions = (json.extensions && json.extensions[this.name]) || {}
    var lightDefs = extensions.lights || []
    var lightDef = lightDefs[lightIndex]
    var lightNode

    var color = new THREE.Color(0xffffff)

    if (lightDef.color !== undefined) color.fromArray(lightDef.color)

    var range = lightDef.range !== undefined ? lightDef.range : 0

    switch (lightDef.type) {
      case 'directional':
        lightNode = new THREE.DirectionalLight(color)
        lightNode.target.position.set(0, 0, -1)
        lightNode.add(lightNode.target)
        break

      case 'point':
        lightNode = new THREE.PointLight(color)
        lightNode.distance = range
        break

      case 'spot':
        lightNode = new THREE.SpotLight(color)
        lightNode.distance = range
        // Handle spotlight properties.
        lightDef.spot = lightDef.spot || {}
        lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0
        lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0
        lightNode.angle = lightDef.spot.outerConeAngle
        lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle
        lightNode.target.position.set(0, 0, -1)
        lightNode.add(lightNode.target)
        break

      default:
        throw new Error('THREE.GLTFLoader: Unexpected light type, "' + lightDef.type + '".')
    }

    // Some lights (e.g. spot) default to a position other than the origin. Reset the position
    // here, because node-level parsing will only override position if explicitly specified.
    lightNode.position.set(0, 0, 0)

    lightNode.decay = 2

    if (lightDef.intensity !== undefined) lightNode.intensity = lightDef.intensity

    lightNode.name = parser.createUniqueName(lightDef.name || 'light_' + lightIndex)

    dependency = Promise.resolve(lightNode)

    parser.cache.add(cacheKey, dependency)

    return dependency
  }

  GLTFLightsExtension.prototype.createNodeAttachment = function (nodeIndex) {
    var self = this
    var parser = this.parser
    var json = parser.json
    var nodeDef = json.nodes[nodeIndex]
    var lightDef = (nodeDef.extensions && nodeDef.extensions[this.name]) || {}
    var lightIndex = lightDef.light

    if (lightIndex === undefined) return null

    return this._loadLight(lightIndex).then(function (light) {
      return parser._getNodeRef(self.cache, lightIndex, light)
    })
  }

  /**
   * Unlit Materials Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
   */
  function GLTFMaterialsUnlitExtension() {
    this.name = EXTENSIONS.KHR_MATERIALS_UNLIT
  }

  GLTFMaterialsUnlitExtension.prototype.getMaterialType = function () {
    return THREE.MeshBasicMaterial
  }

  GLTFMaterialsUnlitExtension.prototype.extendParams = function (materialParams, materialDef, parser) {
    var pending = []

    materialParams.color = new THREE.Color(1.0, 1.0, 1.0)
    materialParams.opacity = 1.0

    var metallicRoughness = materialDef.pbrMetallicRoughness

    if (metallicRoughness) {
      if (Array.isArray(metallicRoughness.baseColorFactor)) {
        var array = metallicRoughness.baseColorFactor

        materialParams.color.fromArray(array)
        materialParams.opacity = array[3]
      }

      if (metallicRoughness.baseColorTexture !== undefined) {
        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture))
      }
    }

    return Promise.all(pending)
  }

  /**
   * Clearcoat Materials Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
   */
  function GLTFMaterialsClearcoatExtension(parser) {
    this.parser = parser
    this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT
  }

  GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function (materialIndex) {
    var parser = this.parser
    var materialDef = parser.json.materials[materialIndex]

    if (!materialDef.extensions || !materialDef.extensions[this.name]) return null

    return THREE.MeshPhysicalMaterial
  }

  GLTFMaterialsClearcoatExtension.prototype.extendMaterialParams = function (materialIndex, materialParams) {
    var parser = this.parser
    var materialDef = parser.json.materials[materialIndex]

    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
      return Promise.resolve()
    }

    var pending = []

    var extension = materialDef.extensions[this.name]

    if (extension.clearcoatFactor !== undefined) {
      materialParams.clearcoat = extension.clearcoatFactor
    }

    if (extension.clearcoatTexture !== undefined) {
      pending.push(parser.assignTexture(materialParams, 'clearcoatMap', extension.clearcoatTexture))
    }

    if (extension.clearcoatRoughnessFactor !== undefined) {
      materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor
    }

    if (extension.clearcoatRoughnessTexture !== undefined) {
      pending.push(parser.assignTexture(materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture))
    }

    if (extension.clearcoatNormalTexture !== undefined) {
      pending.push(parser.assignTexture(materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture))

      if (extension.clearcoatNormalTexture.scale !== undefined) {
        var scale = extension.clearcoatNormalTexture.scale

        materialParams.clearcoatNormalScale = new THREE.Vector2(scale, scale)
      }
    }

    return Promise.all(pending)
  }

  /**
   * Transmission Materials Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
   * Draft: https://github.com/KhronosGroup/glTF/pull/1698
   */
  function GLTFMaterialsTransmissionExtension(parser) {
    this.parser = parser
    this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION
  }

  GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function (materialIndex) {
    var parser = this.parser
    var materialDef = parser.json.materials[materialIndex]

    if (!materialDef.extensions || !materialDef.extensions[this.name]) return null

    return THREE.MeshPhysicalMaterial
  }

  GLTFMaterialsTransmissionExtension.prototype.extendMaterialParams = function (materialIndex, materialParams) {
    var parser = this.parser
    var materialDef = parser.json.materials[materialIndex]

    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
      return Promise.resolve()
    }

    var pending = []

    var extension = materialDef.extensions[this.name]

    if (extension.transmissionFactor !== undefined) {
      materialParams.transmission = extension.transmissionFactor
    }

    if (extension.transmissionTexture !== undefined) {
      pending.push(parser.assignTexture(materialParams, 'transmissionMap', extension.transmissionTexture))
    }

    return Promise.all(pending)
  }

  /**
   * BasisU Texture Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu
   */
  function GLTFTextureBasisUExtension(parser) {
    this.parser = parser
    this.name = EXTENSIONS.KHR_TEXTURE_BASISU
  }

  GLTFTextureBasisUExtension.prototype.loadTexture = function (textureIndex) {
    var parser = this.parser
    var json = parser.json

    var textureDef = json.textures[textureIndex]

    if (!textureDef.extensions || !textureDef.extensions[this.name]) {
      return null
    }

    var extension = textureDef.extensions[this.name]
    var source = json.images[extension.source]
    var loader = parser.options.ktx2Loader

    if (!loader) {
      if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) {
        throw new Error('THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures')
      } else {
        // Assumes that the extension is optional and that a fallback texture is present
        return null
      }
    }

    return parser.loadTextureImage(textureIndex, source, loader)
  }

  /**
   * WebP Texture Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
   */
  function GLTFTextureWebPExtension(parser) {
    this.parser = parser
    this.name = EXTENSIONS.EXT_TEXTURE_WEBP
    this.isSupported = null
  }

  GLTFTextureWebPExtension.prototype.loadTexture = function (textureIndex) {
    var name = this.name
    var parser = this.parser
    var json = parser.json

    var textureDef = json.textures[textureIndex]

    if (!textureDef.extensions || !textureDef.extensions[name]) {
      return null
    }

    var extension = textureDef.extensions[name]
    var source = json.images[extension.source]
    var loader = source.uri ? parser.options.manager.getHandler(source.uri) : parser.textureLoader

    return this.detectSupport().then(function (isSupported) {
      if (isSupported) return parser.loadTextureImage(textureIndex, source, loader)

      if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) {
        throw new Error('THREE.GLTFLoader: WebP required by asset but unsupported.')
      }

      // Fall back to PNG or JPEG.
      return parser.loadTexture(textureIndex)
    })
  }

  GLTFTextureWebPExtension.prototype.detectSupport = function () {
    if (!this.isSupported) {
      this.isSupported = new Promise(function (resolve) {
        var image = new Image()

        // Lossy test image. Support for lossy images doesn't guarantee support for all
        // WebP images, unfortunately.
        image.src = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA'

        image.onload = image.onerror = function () {
          resolve(image.height === 1)
        }
      })
    }

    return this.isSupported
  }

  /**
   * meshopt BufferView Compression Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
   */
  function GLTFMeshoptCompression(parser) {
    this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION
    this.parser = parser
  }

  GLTFMeshoptCompression.prototype.loadBufferView = function (index) {
    var json = this.parser.json
    var bufferView = json.bufferViews[index]

    if (bufferView.extensions && bufferView.extensions[this.name]) {
      var extensionDef = bufferView.extensions[this.name]

      var buffer = this.parser.getDependency('buffer', extensionDef.buffer)
      var decoder = this.parser.options.meshoptDecoder

      if (!decoder || !decoder.supported) {
        if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) {
          throw new Error('THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files')
        } else {
          // Assumes that the extension is optional and that fallback buffer data is present
          return null
        }
      }

      return Promise.all([buffer, decoder.ready]).then(function (res) {
        var byteOffset = extensionDef.byteOffset || 0
        var byteLength = extensionDef.byteLength || 0

        var count = extensionDef.count
        var stride = extensionDef.byteStride

        var result = new ArrayBuffer(count * stride)
        var source = new Uint8Array(res[0], byteOffset, byteLength)

        decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter)
        return result
      })
    } else {
      return null
    }
  }

  /* BINARY EXTENSION */
  var BINARY_EXTENSION_HEADER_MAGIC = 'glTF'
  var BINARY_EXTENSION_HEADER_LENGTH = 12
  var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4e4f534a, BIN: 0x004e4942 }

  function GLTFBinaryExtension(data) {
    this.name = EXTENSIONS.KHR_BINARY_GLTF
    this.content = null
    this.body = null

    var headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH)

    this.header = {
      magic: THREE.LoaderUtils.decodeText(new Uint8Array(data.slice(0, 4))),
      version: headerView.getUint32(4, true),
      length: headerView.getUint32(8, true)
    }

    if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
      throw new Error('THREE.GLTFLoader: Unsupported glTF-Binary header.')
    } else if (this.header.version < 2.0) {
      throw new Error('THREE.GLTFLoader: Legacy binary file detected.')
    }

    var chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH)
    var chunkIndex = 0

    while (chunkIndex < chunkView.byteLength) {
      var chunkLength = chunkView.getUint32(chunkIndex, true)
      chunkIndex += 4

      var chunkType = chunkView.getUint32(chunkIndex, true)
      chunkIndex += 4

      if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
        var contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength)
        this.content = THREE.LoaderUtils.decodeText(contentArray)
      } else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
        var byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex
        this.body = data.slice(byteOffset, byteOffset + chunkLength)
      }

      // Clients must ignore chunks with unknown types.

      chunkIndex += chunkLength
    }

    if (this.content === null) {
      throw new Error('THREE.GLTFLoader: JSON content not found.')
    }
  }

  /**
   * DRACO Mesh Compression Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
   */
  function GLTFDracoMeshCompressionExtension(json, dracoLoader) {
    if (!dracoLoader) {
      throw new Error('THREE.GLTFLoader: No DRACOLoader instance provided.')
    }

    this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION
    this.json = json
    this.dracoLoader = dracoLoader
    this.dracoLoader.preload()
  }

  GLTFDracoMeshCompressionExtension.prototype.decodePrimitive = function (primitive, parser) {
    var json = this.json
    var dracoLoader = this.dracoLoader
    var bufferViewIndex = primitive.extensions[this.name].bufferView
    var gltfAttributeMap = primitive.extensions[this.name].attributes
    var threeAttributeMap = {}
    var attributeNormalizedMap = {}
    var attributeTypeMap = {}

    for (var attributeName in gltfAttributeMap) {
      var threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase()

      threeAttributeMap[threeAttributeName] = gltfAttributeMap[attributeName]
    }

    for (attributeName in primitive.attributes) {
      var threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase()

      if (gltfAttributeMap[attributeName] !== undefined) {
        var accessorDef = json.accessors[primitive.attributes[attributeName]]
        var componentType = WEBGL_COMPONENT_TYPES[accessorDef.componentType]

        attributeTypeMap[threeAttributeName] = componentType
        attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true
      }
    }

    return parser.getDependency('bufferView', bufferViewIndex).then(function (bufferView) {
      return new Promise(function (resolve) {
        dracoLoader.decodeDracoFile(
          bufferView,
          function (geometry) {
            for (var attributeName in geometry.attributes) {
              var attribute = geometry.attributes[attributeName]
              var normalized = attributeNormalizedMap[attributeName]

              if (normalized !== undefined) attribute.normalized = normalized
            }

            resolve(geometry)
          },
          threeAttributeMap,
          attributeTypeMap
        )
      })
    })
  }

  /**
   * Texture Transform Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
   */
  function GLTFTextureTransformExtension() {
    this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM
  }

  GLTFTextureTransformExtension.prototype.extendTexture = function (texture, transform) {
    texture = texture.clone()

    if (transform.offset !== undefined) {
      texture.offset.fromArray(transform.offset)
    }

    if (transform.rotation !== undefined) {
      texture.rotation = transform.rotation
    }

    if (transform.scale !== undefined) {
      texture.repeat.fromArray(transform.scale)
    }

    if (transform.texCoord !== undefined) {
      console.warn('THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.')
    }

    texture.needsUpdate = true

    return texture
  }

  /**
   * Specular-Glossiness Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
   */

  /**
   * A sub class of THREE.StandardMaterial with some of the functionality
   * changed via the `onBeforeCompile` callback
   * @pailhead
   */

  function GLTFMeshStandardSGMaterial(params) {
    THREE.MeshStandardMaterial.call(this)

    this.isGLTFSpecularGlossinessMaterial = true

    //various chunks that need replacing
    var specularMapParsFragmentChunk = ['#ifdef USE_SPECULARMAP', '	uniform sampler2D specularMap;', '#endif'].join('\n')

    var glossinessMapParsFragmentChunk = ['#ifdef USE_GLOSSINESSMAP', '	uniform sampler2D glossinessMap;', '#endif'].join('\n')

    var specularMapFragmentChunk = [
      'vec3 specularFactor = specular;',
      '#ifdef USE_SPECULARMAP',
      '	vec4 texelSpecular = texture2D( specularMap, vUv );',
      '	texelSpecular = sRGBToLinear( texelSpecular );',
      '	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture',
      '	specularFactor *= texelSpecular.rgb;',
      '#endif'
    ].join('\n')

    var glossinessMapFragmentChunk = [
      'float glossinessFactor = glossiness;',
      '#ifdef USE_GLOSSINESSMAP',
      '	vec4 texelGlossiness = texture2D( glossinessMap, vUv );',
      '	// reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture',
      '	glossinessFactor *= texelGlossiness.a;',
      '#endif'
    ].join('\n')

    var lightPhysicalFragmentChunk = [
      'PhysicalMaterial material;',
      'material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );',
      'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );',
      'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );',
      'material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.',
      'material.specularRoughness += geometryRoughness;',
      'material.specularRoughness = min( material.specularRoughness, 1.0 );',
      'material.specularColor = specularFactor;'
    ].join('\n')

    var uniforms = {
      specular: { value: new THREE.Color().setHex(0xffffff) },
      glossiness: { value: 1 },
      specularMap: { value: null },
      glossinessMap: { value: null }
    }

    this._extraUniforms = uniforms

    this.onBeforeCompile = function (shader) {
      for (var uniformName in uniforms) {
        shader.uniforms[uniformName] = uniforms[uniformName]
      }

      shader.fragmentShader = shader.fragmentShader
        .replace('uniform float roughness;', 'uniform vec3 specular;')
        .replace('uniform float metalness;', 'uniform float glossiness;')
        .replace('#include <roughnessmap_pars_fragment>', specularMapParsFragmentChunk)
        .replace('#include <metalnessmap_pars_fragment>', glossinessMapParsFragmentChunk)
        .replace('#include <roughnessmap_fragment>', specularMapFragmentChunk)
        .replace('#include <metalnessmap_fragment>', glossinessMapFragmentChunk)
        .replace('#include <lights_physical_fragment>', lightPhysicalFragmentChunk)
    }

    Object.defineProperties(this, {
      specular: {
        get: function () {
          return uniforms.specular.value
        },
        set: function (v) {
          uniforms.specular.value = v
        }
      },

      specularMap: {
        get: function () {
          return uniforms.specularMap.value
        },
        set: function (v) {
          uniforms.specularMap.value = v

          if (v) {
            this.defines.USE_SPECULARMAP = '' // USE_UV is set by the renderer for specular maps
          } else {
            delete this.defines.USE_SPECULARMAP
          }
        }
      },

      glossiness: {
        get: function () {
          return uniforms.glossiness.value
        },
        set: function (v) {
          uniforms.glossiness.value = v
        }
      },

      glossinessMap: {
        get: function () {
          return uniforms.glossinessMap.value
        },
        set: function (v) {
          uniforms.glossinessMap.value = v

          if (v) {
            this.defines.USE_GLOSSINESSMAP = ''
            this.defines.USE_UV = ''
          } else {
            delete this.defines.USE_GLOSSINESSMAP
            delete this.defines.USE_UV
          }
        }
      }
    })

    delete this.metalness
    delete this.roughness
    delete this.metalnessMap
    delete this.roughnessMap

    this.setValues(params)
  }

  GLTFMeshStandardSGMaterial.prototype = Object.create(THREE.MeshStandardMaterial.prototype)
  GLTFMeshStandardSGMaterial.prototype.constructor = GLTFMeshStandardSGMaterial

  GLTFMeshStandardSGMaterial.prototype.copy = function (source) {
    THREE.MeshStandardMaterial.prototype.copy.call(this, source)
    this.specularMap = source.specularMap
    this.specular.copy(source.specular)
    this.glossinessMap = source.glossinessMap
    this.glossiness = source.glossiness
    delete this.metalness
    delete this.roughness
    delete this.metalnessMap
    delete this.roughnessMap
    return this
  }

  function GLTFMaterialsPbrSpecularGlossinessExtension() {
    return {
      name: EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,

      specularGlossinessParams: [
        'color',
        'map',
        'lightMap',
        'lightMapIntensity',
        'aoMap',
        'aoMapIntensity',
        'emissive',
        'emissiveIntensity',
        'emissiveMap',
        'bumpMap',
        'bumpScale',
        'normalMap',
        'normalMapType',
        'displacementMap',
        'displacementScale',
        'displacementBias',
        'specularMap',
        'specular',
        'glossinessMap',
        'glossiness',
        'alphaMap',
        'envMap',
        'envMapIntensity',
        'refractionRatio'
      ],

      getMaterialType: function () {
        return GLTFMeshStandardSGMaterial
      },

      extendParams: function (materialParams, materialDef, parser) {
        var pbrSpecularGlossiness = materialDef.extensions[this.name]

        materialParams.color = new THREE.Color(1.0, 1.0, 1.0)
        materialParams.opacity = 1.0

        var pending = []

        if (Array.isArray(pbrSpecularGlossiness.diffuseFactor)) {
          var array = pbrSpecularGlossiness.diffuseFactor

          materialParams.color.fromArray(array)
          materialParams.opacity = array[3]
        }

        if (pbrSpecularGlossiness.diffuseTexture !== undefined) {
          pending.push(parser.assignTexture(materialParams, 'map', pbrSpecularGlossiness.diffuseTexture))
        }

        materialParams.emissive = new THREE.Color(0.0, 0.0, 0.0)
        materialParams.glossiness = pbrSpecularGlossiness.glossinessFactor !== undefined ? pbrSpecularGlossiness.glossinessFactor : 1.0
        materialParams.specular = new THREE.Color(1.0, 1.0, 1.0)

        if (Array.isArray(pbrSpecularGlossiness.specularFactor)) {
          materialParams.specular.fromArray(pbrSpecularGlossiness.specularFactor)
        }

        if (pbrSpecularGlossiness.specularGlossinessTexture !== undefined) {
          var specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture
          pending.push(parser.assignTexture(materialParams, 'glossinessMap', specGlossMapDef))
          pending.push(parser.assignTexture(materialParams, 'specularMap', specGlossMapDef))
        }

        return Promise.all(pending)
      },

      createMaterial: function (materialParams) {
        var material = new GLTFMeshStandardSGMaterial(materialParams)
        material.fog = true

        material.color = materialParams.color

        material.map = materialParams.map === undefined ? null : materialParams.map

        material.lightMap = null
        material.lightMapIntensity = 1.0

        material.aoMap = materialParams.aoMap === undefined ? null : materialParams.aoMap
        material.aoMapIntensity = 1.0

        material.emissive = materialParams.emissive
        material.emissiveIntensity = 1.0
        material.emissiveMap = materialParams.emissiveMap === undefined ? null : materialParams.emissiveMap

        material.bumpMap = materialParams.bumpMap === undefined ? null : materialParams.bumpMap
        material.bumpScale = 1

        material.normalMap = materialParams.normalMap === undefined ? null : materialParams.normalMap
        material.normalMapType = THREE.TangentSpaceNormalMap

        if (materialParams.normalScale) material.normalScale = materialParams.normalScale

        material.displacementMap = null
        material.displacementScale = 1
        material.displacementBias = 0

        material.specularMap = materialParams.specularMap === undefined ? null : materialParams.specularMap
        material.specular = materialParams.specular

        material.glossinessMap = materialParams.glossinessMap === undefined ? null : materialParams.glossinessMap
        material.glossiness = materialParams.glossiness

        material.alphaMap = null

        material.envMap = materialParams.envMap === undefined ? null : materialParams.envMap
        material.envMapIntensity = 1.0

        material.refractionRatio = 0.98

        return material
      }
    }
  }

  /**
   * Mesh Quantization Extension
   *
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
   */
  function GLTFMeshQuantizationExtension() {
    this.name = EXTENSIONS.KHR_MESH_QUANTIZATION
  }

  /*********************************/
  /********** INTERPOLATION ********/
  /*********************************/

  // Spline Interpolation
  // Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
  function GLTFCubicSplineInterpolant(parameterPositions, sampleValues, sampleSize, resultBuffer) {
    THREE.Interpolant.call(this, parameterPositions, sampleValues, sampleSize, resultBuffer)
  }

  GLTFCubicSplineInterpolant.prototype = Object.create(THREE.Interpolant.prototype)
  GLTFCubicSplineInterpolant.prototype.constructor = GLTFCubicSplineInterpolant

  GLTFCubicSplineInterpolant.prototype.copySampleValue_ = function (index) {
    // Copies a sample value to the result buffer. See description of glTF
    // CUBICSPLINE values layout in interpolate_() function below.

    var result = this.resultBuffer,
      values = this.sampleValues,
      valueSize = this.valueSize,
      offset = index * valueSize * 3 + valueSize

    for (var i = 0; i !== valueSize; i++) {
      result[i] = values[offset + i]
    }

    return result
  }

  GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_

  GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_

  GLTFCubicSplineInterpolant.prototype.interpolate_ = function (i1, t0, t, t1) {
    var result = this.resultBuffer
    var values = this.sampleValues
    var stride = this.valueSize

    var stride2 = stride * 2
    var stride3 = stride * 3

    var td = t1 - t0

    var p = (t - t0) / td
    var pp = p * p
    var ppp = pp * p

    var offset1 = i1 * stride3
    var offset0 = offset1 - stride3

    var s2 = -2 * ppp + 3 * pp
    var s3 = ppp - pp
    var s0 = 1 - s2
    var s1 = s3 - pp + p

    // Layout of keyframe output values for CUBICSPLINE animations:
    //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
    for (var i = 0; i !== stride; i++) {
      var p0 = values[offset0 + i + stride] // splineVertex_k
      var m0 = values[offset0 + i + stride2] * td // outTangent_k * (t_k+1 - t_k)
      var p1 = values[offset1 + i + stride] // splineVertex_k+1
      var m1 = values[offset1 + i] * td // inTangent_k+1 * (t_k+1 - t_k)

      result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1
    }

    return result
  }

  /*********************************/
  /********** INTERNALS ************/
  /*********************************/

  /* CONSTANTS */

  var WEBGL_CONSTANTS = {
    FLOAT: 5126,
    //FLOAT_MAT2: 35674,
    FLOAT_MAT3: 35675,
    FLOAT_MAT4: 35676,
    FLOAT_VEC2: 35664,
    FLOAT_VEC3: 35665,
    FLOAT_VEC4: 35666,
    LINEAR: 9729,
    REPEAT: 10497,
    SAMPLER_2D: 35678,
    POINTS: 0,
    LINES: 1,
    LINE_LOOP: 2,
    LINE_STRIP: 3,
    TRIANGLES: 4,
    TRIANGLE_STRIP: 5,
    TRIANGLE_FAN: 6,
    UNSIGNED_BYTE: 5121,
    UNSIGNED_SHORT: 5123
  }

  var WEBGL_COMPONENT_TYPES = {
    5120: Int8Array,
    5121: Uint8Array,
    5122: Int16Array,
    5123: Uint16Array,
    5125: Uint32Array,
    5126: Float32Array
  }

  var WEBGL_FILTERS = {
    9728: THREE.NearestFilter,
    9729: THREE.LinearFilter,
    9984: THREE.NearestMipmapNearestFilter,
    9985: THREE.LinearMipmapNearestFilter,
    9986: THREE.NearestMipmapLinearFilter,
    9987: THREE.LinearMipmapLinearFilter
  }

  var WEBGL_WRAPPINGS = {
    33071: THREE.ClampToEdgeWrapping,
    33648: THREE.MirroredRepeatWrapping,
    10497: THREE.RepeatWrapping
  }

  var WEBGL_TYPE_SIZES = {
    SCALAR: 1,
    VEC2: 2,
    VEC3: 3,
    VEC4: 4,
    MAT2: 4,
    MAT3: 9,
    MAT4: 16
  }

  var ATTRIBUTES = {
    POSITION: 'position',
    NORMAL: 'normal',
    TANGENT: 'tangent',
    TEXCOORD_0: 'uv',
    TEXCOORD_1: 'uv2',
    COLOR_0: 'color',
    WEIGHTS_0: 'skinWeight',
    JOINTS_0: 'skinIndex'
  }

  var PATH_PROPERTIES = {
    scale: 'scale',
    translation: 'position',
    rotation: 'quaternion',
    weights: 'morphTargetInfluences'
  }

  var INTERPOLATION = {
    CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
    // keyframe track will be initialized with a default interpolation type, then modified.
    LINEAR: THREE.InterpolateLinear,
    STEP: THREE.InterpolateDiscrete
  }

  var ALPHA_MODES = {
    OPAQUE: 'OPAQUE',
    MASK: 'MASK',
    BLEND: 'BLEND'
  }

  /* UTILITY FUNCTIONS */

  function 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
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
   */
  function createDefaultMaterial(cache) {
    if (cache['DefaultMaterial'] === undefined) {
      cache['DefaultMaterial'] = new THREE.MeshStandardMaterial({
        color: 0xffffff,
        emissive: 0x000000,
        metalness: 1,
        roughness: 1,
        transparent: false,
        depthTest: true,
        side: THREE.FrontSide
      })
    }

    return cache['DefaultMaterial']
  }

  function addUnknownExtensionsToUserData(knownExtensions, object, objectDef) {
    // Add unknown glTF extensions to an object's userData.

    for (var name in objectDef.extensions) {
      if (knownExtensions[name] === undefined) {
        object.userData.gltfExtensions = object.userData.gltfExtensions || {}
        object.userData.gltfExtensions[name] = objectDef.extensions[name]
      }
    }
  }

  /**
   * @param {THREE.Object3D|THREE.Material|THREE.BufferGeometry} object
   * @param {GLTF.definition} gltfDef
   */
  function assignExtrasToUserData(object, gltfDef) {
    if (gltfDef.extras !== undefined) {
      if (typeof gltfDef.extras === 'object') {
        Object.assign(object.userData, gltfDef.extras)
      } else {
        console.warn('THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras)
      }
    }
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
   *
   * @param {THREE.BufferGeometry} geometry
   * @param {Array<GLTF.Target>} targets
   * @param {GLTFParser} parser
   * @return {Promise<THREE.BufferGeometry>}
   */
  function addMorphTargets(geometry, targets, parser) {
    var hasMorphPosition = false
    var hasMorphNormal = false

    for (var i = 0, il = targets.length; i < il; i++) {
      var target = targets[i]

      if (target.POSITION !== undefined) hasMorphPosition = true
      if (target.NORMAL !== undefined) hasMorphNormal = true

      if (hasMorphPosition && hasMorphNormal) break
    }

    if (!hasMorphPosition && !hasMorphNormal) return Promise.resolve(geometry)

    var pendingPositionAccessors = []
    var pendingNormalAccessors = []

    for (var i = 0, il = targets.length; i < il; i++) {
      var target = targets[i]

      if (hasMorphPosition) {
        var pendingAccessor = target.POSITION !== undefined ? parser.getDependency('accessor', target.POSITION) : geometry.attributes.position

        pendingPositionAccessors.push(pendingAccessor)
      }

      if (hasMorphNormal) {
        var pendingAccessor = target.NORMAL !== undefined ? parser.getDependency('accessor', target.NORMAL) : geometry.attributes.normal

        pendingNormalAccessors.push(pendingAccessor)
      }
    }

    return Promise.all([Promise.all(pendingPositionAccessors), Promise.all(pendingNormalAccessors)]).then(function (accessors) {
      var morphPositions = accessors[0]
      var morphNormals = accessors[1]

      if (hasMorphPosition) geometry.morphAttributes.position = morphPositions
      if (hasMorphNormal) geometry.morphAttributes.normal = morphNormals
      geometry.morphTargetsRelative = true

      return geometry
    })
  }

  /**
   * @param {THREE.Mesh} mesh
   * @param {GLTF.Mesh} meshDef
   */
  function updateMorphTargets(mesh, meshDef) {
    mesh.updateMorphTargets()

    if (meshDef.weights !== undefined) {
      for (var i = 0, il = meshDef.weights.length; i < il; i++) {
        mesh.morphTargetInfluences[i] = meshDef.weights[i]
      }
    }

    // .extras has user-defined data, so check that .extras.targetNames is an array.
    if (meshDef.extras && Array.isArray(meshDef.extras.targetNames)) {
      var targetNames = meshDef.extras.targetNames

      if (mesh.morphTargetInfluences.length === targetNames.length) {
        mesh.morphTargetDictionary = {}

        for (var i = 0, il = targetNames.length; i < il; i++) {
          mesh.morphTargetDictionary[targetNames[i]] = i
        }
      } else {
        console.warn('THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.')
      }
    }
  }

  function createPrimitiveKey(primitiveDef) {
    var dracoExtension = primitiveDef.extensions && primitiveDef.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]
    var geometryKey

    if (dracoExtension) {
      geometryKey = 'draco:' + dracoExtension.bufferView + ':' + dracoExtension.indices + ':' + createAttributesKey(dracoExtension.attributes)
    } else {
      geometryKey = primitiveDef.indices + ':' + createAttributesKey(primitiveDef.attributes) + ':' + primitiveDef.mode
    }

    return geometryKey
  }

  function createAttributesKey(attributes) {
    var attributesKey = ''

    var keys = Object.keys(attributes).sort()

    for (var i = 0, il = keys.length; i < il; i++) {
      attributesKey += keys[i] + ':' + attributes[keys[i]] + ';'
    }

    return attributesKey
  }

  /* GLTF PARSER */

  function GLTFParser(json, options) {
    this.json = json || {}
    this.extensions = {}
    this.plugins = {}
    this.options = options || {}

    // loader object cache
    this.cache = new GLTFRegistry()

    // associations between Three.js objects and glTF elements
    this.associations = new Map()

    // BufferGeometry caching
    this.primitiveCache = {}

    // Object3D instance caches
    this.meshCache = { refs: {}, uses: {} }
    this.cameraCache = { refs: {}, uses: {} }
    this.lightCache = { refs: {}, uses: {} }

    // Track node names, to ensure no duplicates
    this.nodeNamesUsed = {}

    // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
    // expensive work of uploading a texture to the GPU off the main thread.
    if (typeof createImageBitmap !== 'undefined' && /Firefox/.test(navigator.userAgent) === false) {
      this.textureLoader = new THREE.ImageBitmapLoader(this.options.manager)
    } else {
      this.textureLoader = new THREE.TextureLoader(this.options.manager)
    }

    this.textureLoader.setCrossOrigin(this.options.crossOrigin)

    this.fileLoader = new THREE.FileLoader(this.options.manager)
    this.fileLoader.setResponseType('arraybuffer')

    if (this.options.crossOrigin === 'use-credentials') {
      this.fileLoader.setWithCredentials(true)
    }
  }

  GLTFParser.prototype.setExtensions = function (extensions) {
    this.extensions = extensions
  }

  GLTFParser.prototype.setPlugins = function (plugins) {
    this.plugins = plugins
  }

  GLTFParser.prototype.parse = function (onLoad, onError) {
    var parser = this
    var json = this.json
    var extensions = this.extensions

    // Clear the loader cache
    this.cache.removeAll()

    // Mark the special nodes/meshes in json for efficient parse
    this._invokeAll(function (ext) {
      return ext._markDefs && ext._markDefs()
    })

    Promise.all([this.getDependencies('scene'), this.getDependencies('animation'), this.getDependencies('camera')])
      .then(function (dependencies) {
        var result = {
          scene: dependencies[0][json.scene || 0],
          scenes: dependencies[0],
          animations: dependencies[1],
          cameras: dependencies[2],
          asset: json.asset,
          parser: parser,
          userData: {}
        }

        addUnknownExtensionsToUserData(extensions, result, json)

        assignExtrasToUserData(result, json)

        onLoad(result)
      })
      .catch(onError)
  }

  /**
   * Marks the special nodes/meshes in json for efficient parse.
   */
  GLTFParser.prototype._markDefs = function () {
    var nodeDefs = this.json.nodes || []
    var skinDefs = this.json.skins || []
    var meshDefs = this.json.meshes || []

    // Nothing in the node definition indicates whether it is a Bone or an
    // Object3D. Use the skins' joint references to mark bones.
    for (var skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex++) {
      var joints = skinDefs[skinIndex].joints

      for (var i = 0, il = joints.length; i < il; i++) {
        nodeDefs[joints[i]].isBone = true
      }
    }

    // Iterate over all nodes, marking references to shared resources,
    // as well as skeleton joints.
    for (var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
      var nodeDef = nodeDefs[nodeIndex]

      if (nodeDef.mesh !== undefined) {
        this._addNodeRef(this.meshCache, nodeDef.mesh)

        // Nothing in the mesh definition indicates whether it is
        // a SkinnedMesh or Mesh. Use the node's mesh reference
        // to mark SkinnedMesh if node has skin.
        if (nodeDef.skin !== undefined) {
          meshDefs[nodeDef.mesh].isSkinnedMesh = true
        }
      }

      if (nodeDef.camera !== undefined) {
        this._addNodeRef(this.cameraCache, nodeDef.camera)
      }
    }
  }

  /**
   * Counts references to shared node / Object3D resources. These resources
   * can be reused, or "instantiated", at multiple nodes in the scene
   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
   * be marked. Non-scenegraph resources (like Materials, Geometries, and
   * Textures) can be reused directly and are not marked here.
   *
   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
   */
  GLTFParser.prototype._addNodeRef = function (cache, index) {
    if (index === undefined) return

    if (cache.refs[index] === undefined) {
      cache.refs[index] = cache.uses[index] = 0
    }

    cache.refs[index]++
  }

  /** Returns a reference to a shared resource, cloning it if necessary. */
  GLTFParser.prototype._getNodeRef = function (cache, index, object) {
    if (cache.refs[index] <= 1) return object

    var ref = object.clone()

    ref.name += '_instance_' + cache.uses[index]++

    return ref
  }

  GLTFParser.prototype._invokeOne = function (func) {
    var extensions = Object.values(this.plugins)
    extensions.push(this)

    for (var i = 0; i < extensions.length; i++) {
      var result = func(extensions[i])

      if (result) return result
    }
  }

  GLTFParser.prototype._invokeAll = function (func) {
    var extensions = Object.values(this.plugins)
    extensions.unshift(this)

    var pending = []

    for (var i = 0; i < extensions.length; i++) {
      var result = func(extensions[i])

      if (result) pending.push(result)
    }

    return pending
  }

  /**
   * Requests the specified dependency asynchronously, with caching.
   * @param {string} type
   * @param {number} index
   * @return {Promise<THREE.Object3D|THREE.Material|THREE.Texture|THREE.AnimationClip|ArrayBuffer|Object>}
   */
  GLTFParser.prototype.getDependency = function (type, index) {
    var cacheKey = type + ':' + index
    var dependency = this.cache.get(cacheKey)

    if (!dependency) {
      switch (type) {
        case 'scene':
          dependency = this.loadScene(index)
          break

        case 'node':
          dependency = this.loadNode(index)
          break

        case 'mesh':
          dependency = this._invokeOne(function (ext) {
            return ext.loadMesh && ext.loadMesh(index)
          })
          break

        case 'accessor':
          dependency = this.loadAccessor(index)
          break

        case 'bufferView':
          dependency = this._invokeOne(function (ext) {
            return ext.loadBufferView && ext.loadBufferView(index)
          })
          break

        case 'buffer':
          dependency = this.loadBuffer(index)
          break

        case 'material':
          dependency = this._invokeOne(function (ext) {
            return ext.loadMaterial && ext.loadMaterial(index)
          })
          break

        case 'texture':
          dependency = this._invokeOne(function (ext) {
            return ext.loadTexture && ext.loadTexture(index)
          })
          break

        case 'skin':
          dependency = this.loadSkin(index)
          break

        case 'animation':
          dependency = this.loadAnimation(index)
          break

        case 'camera':
          dependency = this.loadCamera(index)
          break

        default:
          throw new Error('Unknown type: ' + type)
      }

      this.cache.add(cacheKey, dependency)
    }

    return dependency
  }

  /**
   * Requests all dependencies of the specified type asynchronously, with caching.
   * @param {string} type
   * @return {Promise<Array<Object>>}
   */
  GLTFParser.prototype.getDependencies = function (type) {
    var dependencies = this.cache.get(type)

    if (!dependencies) {
      var parser = this
      var defs = this.json[type + (type === 'mesh' ? 'es' : 's')] || []

      dependencies = Promise.all(
        defs.map(function (def, index) {
          return parser.getDependency(type, index)
        })
      )

      this.cache.add(type, dependencies)
    }

    return dependencies
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
   * @param {number} bufferIndex
   * @return {Promise<ArrayBuffer>}
   */
  GLTFParser.prototype.loadBuffer = function (bufferIndex) {
    var bufferDef = this.json.buffers[bufferIndex]
    var loader = this.fileLoader

    if (bufferDef.type && bufferDef.type !== 'arraybuffer') {
      throw new Error('THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.')
    }

    // If present, GLB container is required to be the first buffer.
    if (bufferDef.uri === undefined && bufferIndex === 0) {
      return Promise.resolve(this.extensions[EXTENSIONS.KHR_BINARY_GLTF].body)
    }

    var options = this.options

    return new Promise(function (resolve, reject) {
      loader.load(resolveURL(bufferDef.uri, options.path), resolve, undefined, function () {
        reject(new Error('THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".'))
      })
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
   * @param {number} bufferViewIndex
   * @return {Promise<ArrayBuffer>}
   */
  GLTFParser.prototype.loadBufferView = function (bufferViewIndex) {
    var bufferViewDef = this.json.bufferViews[bufferViewIndex]

    return this.getDependency('buffer', bufferViewDef.buffer).then(function (buffer) {
      var byteLength = bufferViewDef.byteLength || 0
      var byteOffset = bufferViewDef.byteOffset || 0
      return buffer.slice(byteOffset, byteOffset + byteLength)
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
   * @param {number} accessorIndex
   * @return {Promise<THREE.BufferAttribute|THREE.InterleavedBufferAttribute>}
   */
  GLTFParser.prototype.loadAccessor = function (accessorIndex) {
    var parser = this
    var json = this.json

    var accessorDef = this.json.accessors[accessorIndex]

    if (accessorDef.bufferView === undefined && accessorDef.sparse === undefined) {
      // Ignore empty accessors, which may be used to declare runtime
      // information about attributes coming from another source (e.g. Draco
      // compression extension).
      return Promise.resolve(null)
    }

    var pendingBufferViews = []

    if (accessorDef.bufferView !== undefined) {
      pendingBufferViews.push(this.getDependency('bufferView', accessorDef.bufferView))
    } else {
      pendingBufferViews.push(null)
    }

    if (accessorDef.sparse !== undefined) {
      pendingBufferViews.push(this.getDependency('bufferView', accessorDef.sparse.indices.bufferView))
      pendingBufferViews.push(this.getDependency('bufferView', accessorDef.sparse.values.bufferView))
    }

    return Promise.all(pendingBufferViews).then(function (bufferViews) {
      var bufferView = bufferViews[0]

      var itemSize = WEBGL_TYPE_SIZES[accessorDef.type]
      var TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType]

      // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
      var elementBytes = TypedArray.BYTES_PER_ELEMENT
      var itemBytes = elementBytes * itemSize
      var byteOffset = accessorDef.byteOffset || 0
      var byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[accessorDef.bufferView].byteStride : undefined
      var normalized = accessorDef.normalized === true
      var array, bufferAttribute

      // The buffer is not interleaved if the stride is the item size in bytes.
      if (byteStride && byteStride !== itemBytes) {
        // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
        // This makes sure that IBA.count reflects accessor.count properly
        var ibSlice = Math.floor(byteOffset / byteStride)
        var ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count
        var ib = parser.cache.get(ibCacheKey)

        if (!ib) {
          array = new TypedArray(bufferView, ibSlice * byteStride, (accessorDef.count * byteStride) / elementBytes)

          // Integer parameters to IB/IBA are in array elements, not bytes.
          ib = new THREE.InterleavedBuffer(array, byteStride / elementBytes)

          parser.cache.add(ibCacheKey, ib)
        }

        bufferAttribute = new THREE.InterleavedBufferAttribute(ib, itemSize, (byteOffset % byteStride) / elementBytes, normalized)
      } else {
        if (bufferView === null) {
          array = new TypedArray(accessorDef.count * itemSize)
        } else {
          array = new TypedArray(bufferView, byteOffset, accessorDef.count * itemSize)
        }

        bufferAttribute = new THREE.BufferAttribute(array, itemSize, normalized)
      }

      // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
      if (accessorDef.sparse !== undefined) {
        var itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR
        var TypedArrayIndices = WEBGL_COMPONENT_TYPES[accessorDef.sparse.indices.componentType]

        var byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0
        var byteOffsetValues = accessorDef.sparse.values.byteOffset || 0

        var sparseIndices = new TypedArrayIndices(bufferViews[1], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices)
        var sparseValues = new TypedArray(bufferViews[2], byteOffsetValues, accessorDef.sparse.count * itemSize)

        if (bufferView !== null) {
          // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
          bufferAttribute = new THREE.BufferAttribute(bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized)
        }

        for (var i = 0, il = sparseIndices.length; i < il; i++) {
          var index = sparseIndices[i]

          bufferAttribute.setX(index, sparseValues[i * itemSize])
          if (itemSize >= 2) bufferAttribute.setY(index, sparseValues[i * itemSize + 1])
          if (itemSize >= 3) bufferAttribute.setZ(index, sparseValues[i * itemSize + 2])
          if (itemSize >= 4) bufferAttribute.setW(index, sparseValues[i * itemSize + 3])
          if (itemSize >= 5) throw new Error('THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.')
        }
      }

      return bufferAttribute
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
   * @param {number} textureIndex
   * @return {Promise<THREE.Texture>}
   */
  GLTFParser.prototype.loadTexture = function (textureIndex) {
    var parser = this
    var json = this.json
    var options = this.options

    var textureDef = json.textures[textureIndex]

    var textureExtensions = textureDef.extensions || {}

    var source

    if (textureExtensions[EXTENSIONS.MSFT_TEXTURE_DDS]) {
      source = json.images[textureExtensions[EXTENSIONS.MSFT_TEXTURE_DDS].source]
    } else {
      source = json.images[textureDef.source]
    }

    var loader

    if (source.uri) {
      loader = options.manager.getHandler(source.uri)
    }

    if (!loader) {
      loader = textureExtensions[EXTENSIONS.MSFT_TEXTURE_DDS] ? parser.extensions[EXTENSIONS.MSFT_TEXTURE_DDS].ddsLoader : this.textureLoader
    }

    return this.loadTextureImage(textureIndex, source, loader)
  }

  GLTFParser.prototype.loadTextureImage = function (textureIndex, source, loader) {
    var parser = this
    var json = this.json
    var options = this.options

    var textureDef = json.textures[textureIndex]

    var URL = self.URL || self.webkitURL

    var sourceURI = source.uri
    var isObjectURL = false
    var hasAlpha = true

    if (source.mimeType === 'image/jpeg') hasAlpha = false

    if (source.bufferView !== undefined) {
      // Load binary image data from bufferView, if provided.

      sourceURI = parser.getDependency('bufferView', source.bufferView).then(function (bufferView) {
        if (source.mimeType === 'image/png') {
          // Inspect the PNG 'IHDR' chunk to determine whether the image could have an
          // alpha channel. This check is conservative — the image could have an alpha
          // channel with all values == 1, and the indexed type (colorType == 3) only
          // sometimes contains alpha.
          //
          // https://en.wikipedia.org/wiki/Portable_Network_Graphics#File_header
          var colorType = new DataView(bufferView, 25, 1).getUint8(0, false)
          hasAlpha = colorType === 6 || colorType === 4 || colorType === 3
        }

        isObjectURL = true
        var blob = new Blob([bufferView], { type: source.mimeType })
        sourceURI = URL.createObjectURL(blob)
        return sourceURI
      })
    }

    return Promise.resolve(sourceURI)
      .then(function (sourceURI) {
        return new Promise(function (resolve, reject) {
          var onLoad = resolve

          if (loader.isImageBitmapLoader === true) {
            onLoad = function (imageBitmap) {
              resolve(new THREE.CanvasTexture(imageBitmap))
            }
          }

          loader.load(resolveURL(sourceURI, options.path), onLoad, undefined, reject)
        })
      })
      .then(function (texture) {
        // Clean up resources and configure Texture.

        if (isObjectURL === true) {
          URL.revokeObjectURL(sourceURI)
        }

        texture.flipY = false

        if (textureDef.name) texture.name = textureDef.name

        // When there is definitely no alpha channel in the texture, set RGBFormat to save space.
        if (!hasAlpha) texture.format = THREE.RGBFormat

        var samplers = json.samplers || {}
        var sampler = samplers[textureDef.sampler] || {}

        texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || THREE.LinearFilter
        texture.minFilter = WEBGL_FILTERS[sampler.minFilter] || THREE.LinearMipmapLinearFilter
        texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || THREE.RepeatWrapping
        texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || THREE.RepeatWrapping

        parser.associations.set(texture, {
          type: 'textures',
          index: textureIndex
        })

        return texture
      })
  }

  /**
   * Asynchronously assigns a texture to the given material parameters.
   * @param {Object} materialParams
   * @param {string} mapName
   * @param {Object} mapDef
   * @return {Promise}
   */
  GLTFParser.prototype.assignTexture = function (materialParams, mapName, mapDef) {
    var parser = this

    return this.getDependency('texture', mapDef.index).then(function (texture) {
      // Materials sample aoMap from UV set 1 and other maps from UV set 0 - this can't be configured
      // However, we will copy UV set 0 to UV set 1 on demand for aoMap
      if (mapDef.texCoord !== undefined && mapDef.texCoord != 0 && !(mapName === 'aoMap' && mapDef.texCoord == 1)) {
        console.warn('THREE.GLTFLoader: Custom UV set ' + mapDef.texCoord + ' for texture ' + mapName + ' not yet supported.')
      }

      if (parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM]) {
        var transform = mapDef.extensions !== undefined ? mapDef.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM] : undefined

        if (transform) {
          var gltfReference = parser.associations.get(texture)
          texture = parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM].extendTexture(texture, transform)
          parser.associations.set(texture, gltfReference)
        }
      }

      materialParams[mapName] = texture
    })
  }

  /**
   * Assigns final material to a Mesh, Line, or Points instance. The instance
   * already has a material (generated from the glTF material options alone)
   * but reuse of the same glTF material may require multiple threejs materials
   * to accomodate different primitive types, defines, etc. New materials will
   * be created if necessary, and reused from a cache.
   * @param  {THREE.Object3D} mesh Mesh, Line, or Points instance.
   */
  GLTFParser.prototype.assignFinalMaterial = function (mesh) {
    var geometry = mesh.geometry
    var material = mesh.material

    var useVertexTangents = geometry.attributes.tangent !== undefined
    var useVertexColors = geometry.attributes.color !== undefined
    var useFlatShading = geometry.attributes.normal === undefined
    var useSkinning = mesh.isSkinnedMesh === true
    var useMorphTargets = Object.keys(geometry.morphAttributes).length > 0
    var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== undefined

    if (mesh.isPoints) {
      var cacheKey = 'PointsMaterial:' + material.uuid

      var pointsMaterial = this.cache.get(cacheKey)

      if (!pointsMaterial) {
        pointsMaterial = new THREE.PointsMaterial()
        THREE.Material.prototype.copy.call(pointsMaterial, material)
        pointsMaterial.color.copy(material.color)
        pointsMaterial.map = material.map
        pointsMaterial.sizeAttenuation = false // glTF spec says points should be 1px

        this.cache.add(cacheKey, pointsMaterial)
      }

      material = pointsMaterial
    } else if (mesh.isLine) {
      var cacheKey = 'LineBasicMaterial:' + material.uuid

      var lineMaterial = this.cache.get(cacheKey)

      if (!lineMaterial) {
        lineMaterial = new THREE.LineBasicMaterial()
        THREE.Material.prototype.copy.call(lineMaterial, material)
        lineMaterial.color.copy(material.color)

        this.cache.add(cacheKey, lineMaterial)
      }

      material = lineMaterial
    }

    // Clone the material if it will be modified
    if (useVertexTangents || useVertexColors || useFlatShading || useSkinning || useMorphTargets) {
      var cacheKey = 'ClonedMaterial:' + material.uuid + ':'

      if (material.isGLTFSpecularGlossinessMaterial) cacheKey += 'specular-glossiness:'
      if (useSkinning) cacheKey += 'skinning:'
      if (useVertexTangents) cacheKey += 'vertex-tangents:'
      if (useVertexColors) cacheKey += 'vertex-colors:'
      if (useFlatShading) cacheKey += 'flat-shading:'
      if (useMorphTargets) cacheKey += 'morph-targets:'
      if (useMorphNormals) cacheKey += 'morph-normals:'

      var cachedMaterial = this.cache.get(cacheKey)

      if (!cachedMaterial) {
        cachedMaterial = material.clone()

        if (useSkinning) cachedMaterial.skinning = true
        if (useVertexTangents) cachedMaterial.vertexTangents = true
        if (useVertexColors) cachedMaterial.vertexColors = true
        if (useFlatShading) cachedMaterial.flatShading = true
        if (useMorphTargets) cachedMaterial.morphTargets = true
        if (useMorphNormals) cachedMaterial.morphNormals = true

        this.cache.add(cacheKey, cachedMaterial)

        this.associations.set(cachedMaterial, this.associations.get(material))
      }

      material = cachedMaterial
    }

    // workarounds for mesh and geometry

    if (material.aoMap && geometry.attributes.uv2 === undefined && geometry.attributes.uv !== undefined) {
      geometry.setAttribute('uv2', geometry.attributes.uv)
    }

    // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
    if (material.normalScale && !useVertexTangents) {
      material.normalScale.y = -material.normalScale.y
    }

    if (material.clearcoatNormalScale && !useVertexTangents) {
      material.clearcoatNormalScale.y = -material.clearcoatNormalScale.y
    }

    mesh.material = material
  }

  GLTFParser.prototype.getMaterialType = function (/* materialIndex */) {
    return THREE.MeshStandardMaterial
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
   * @param {number} materialIndex
   * @return {Promise<THREE.Material>}
   */
  GLTFParser.prototype.loadMaterial = function (materialIndex) {
    var parser = this
    var json = this.json
    var extensions = this.extensions
    var materialDef = json.materials[materialIndex]

    var materialType
    var materialParams = {}
    var materialExtensions = materialDef.extensions || {}

    var pending = []

    if (materialExtensions[EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS]) {
      var sgExtension = extensions[EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS]
      materialType = sgExtension.getMaterialType()
      pending.push(sgExtension.extendParams(materialParams, materialDef, parser))
    } else if (materialExtensions[EXTENSIONS.KHR_MATERIALS_UNLIT]) {
      var kmuExtension = extensions[EXTENSIONS.KHR_MATERIALS_UNLIT]
      materialType = kmuExtension.getMaterialType()
      pending.push(kmuExtension.extendParams(materialParams, materialDef, parser))
    } else {
      // Specification:
      // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material

      var metallicRoughness = materialDef.pbrMetallicRoughness || {}

      materialParams.color = new THREE.Color(1.0, 1.0, 1.0)
      materialParams.opacity = 1.0

      if (Array.isArray(metallicRoughness.baseColorFactor)) {
        var array = metallicRoughness.baseColorFactor

        materialParams.color.fromArray(array)
        materialParams.opacity = array[3]
      }

      if (metallicRoughness.baseColorTexture !== undefined) {
        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture))
      }

      materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0
      materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0

      if (metallicRoughness.metallicRoughnessTexture !== undefined) {
        pending.push(parser.assignTexture(materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture))
        pending.push(parser.assignTexture(materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture))
      }

      materialType = this._invokeOne(function (ext) {
        return ext.getMaterialType && ext.getMaterialType(materialIndex)
      })

      pending.push(
        Promise.all(
          this._invokeAll(function (ext) {
            return ext.extendMaterialParams && ext.extendMaterialParams(materialIndex, materialParams)
          })
        )
      )
    }

    if (materialDef.doubleSided === true) {
      materialParams.side = THREE.DoubleSide
    }

    var alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE

    if (alphaMode === ALPHA_MODES.BLEND) {
      materialParams.transparent = true

      // See: https://github.com/mrdoob/three.js/issues/17706
      materialParams.depthWrite = false
    } else {
      materialParams.transparent = false

      if (alphaMode === ALPHA_MODES.MASK) {
        materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5
      }
    }

    if (materialDef.normalTexture !== undefined && materialType !== THREE.MeshBasicMaterial) {
      pending.push(parser.assignTexture(materialParams, 'normalMap', materialDef.normalTexture))

      materialParams.normalScale = new THREE.Vector2(1, 1)

      if (materialDef.normalTexture.scale !== undefined) {
        materialParams.normalScale.set(materialDef.normalTexture.scale, materialDef.normalTexture.scale)
      }
    }

    if (materialDef.occlusionTexture !== undefined && materialType !== THREE.MeshBasicMaterial) {
      pending.push(parser.assignTexture(materialParams, 'aoMap', materialDef.occlusionTexture))

      if (materialDef.occlusionTexture.strength !== undefined) {
        materialParams.aoMapIntensity = materialDef.occlusionTexture.strength
      }
    }

    if (materialDef.emissiveFactor !== undefined && materialType !== THREE.MeshBasicMaterial) {
      materialParams.emissive = new THREE.Color().fromArray(materialDef.emissiveFactor)
    }

    if (materialDef.emissiveTexture !== undefined && materialType !== THREE.MeshBasicMaterial) {
      pending.push(parser.assignTexture(materialParams, 'emissiveMap', materialDef.emissiveTexture))
    }

    return Promise.all(pending).then(function () {
      var material

      if (materialType === GLTFMeshStandardSGMaterial) {
        material = extensions[EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS].createMaterial(materialParams)
      } else {
        material = new materialType(materialParams)
      }

      if (materialDef.name) material.name = materialDef.name

      // baseColorTexture, emissiveTexture, and specularGlossinessTexture use sRGB encoding.
      if (material.map) material.map.encoding = THREE.sRGBEncoding
      if (material.emissiveMap) material.emissiveMap.encoding = THREE.sRGBEncoding

      assignExtrasToUserData(material, materialDef)

      parser.associations.set(material, { type: 'materials', index: materialIndex })

      if (materialDef.extensions) addUnknownExtensionsToUserData(extensions, material, materialDef)

      return material
    })
  }

  /** When Object3D instances are targeted by animation, they need unique names. */
  GLTFParser.prototype.createUniqueName = function (originalName) {
    var name = THREE.PropertyBinding.sanitizeNodeName(originalName || '')

    for (var i = 1; this.nodeNamesUsed[name]; ++i) {
      name = originalName + '_' + i
    }

    this.nodeNamesUsed[name] = true

    return name
  }

  /**
   * @param {THREE.BufferGeometry} geometry
   * @param {GLTF.Primitive} primitiveDef
   * @param {GLTFParser} parser
   */
  function computeBounds(geometry, primitiveDef, parser) {
    var attributes = primitiveDef.attributes

    var box = new THREE.Box3()

    if (attributes.POSITION !== undefined) {
      var accessor = parser.json.accessors[attributes.POSITION]

      var min = accessor.min
      var max = accessor.max

      // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.

      if (min !== undefined && max !== undefined) {
        box.set(new THREE.Vector3(min[0], min[1], min[2]), new THREE.Vector3(max[0], max[1], max[2]))
      } else {
        console.warn('THREE.GLTFLoader: Missing min/max properties for accessor POSITION.')

        return
      }
    } else {
      return
    }

    var targets = primitiveDef.targets

    if (targets !== undefined) {
      var maxDisplacement = new THREE.Vector3()
      var vector = new THREE.Vector3()

      for (var i = 0, il = targets.length; i < il; i++) {
        var target = targets[i]

        if (target.POSITION !== undefined) {
          var accessor = parser.json.accessors[target.POSITION]
          var min = accessor.min
          var max = accessor.max

          // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.

          if (min !== undefined && max !== undefined) {
            // we need to get max of absolute components because target weight is [-1,1]
            vector.setX(Math.max(Math.abs(min[0]), Math.abs(max[0])))
            vector.setY(Math.max(Math.abs(min[1]), Math.abs(max[1])))
            vector.setZ(Math.max(Math.abs(min[2]), Math.abs(max[2])))

            // Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative
            // to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets
            // are used to implement key-frame animations and as such only two are active at a time - this results in very large
            // boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.
            maxDisplacement.max(vector)
          } else {
            console.warn('THREE.GLTFLoader: Missing min/max properties for accessor POSITION.')
          }
        }
      }

      // As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
      box.expandByVector(maxDisplacement)
    }

    geometry.boundingBox = box

    var sphere = new THREE.Sphere()

    box.getCenter(sphere.center)
    sphere.radius = box.min.distanceTo(box.max) / 2

    geometry.boundingSphere = sphere
  }

  /**
   * @param {THREE.BufferGeometry} geometry
   * @param {GLTF.Primitive} primitiveDef
   * @param {GLTFParser} parser
   * @return {Promise<THREE.BufferGeometry>}
   */
  function addPrimitiveAttributes(geometry, primitiveDef, parser) {
    var attributes = primitiveDef.attributes

    var pending = []

    function assignAttributeAccessor(accessorIndex, attributeName) {
      return parser.getDependency('accessor', accessorIndex).then(function (accessor) {
        geometry.setAttribute(attributeName, accessor)
      })
    }

    for (var gltfAttributeName in attributes) {
      var threeAttributeName = ATTRIBUTES[gltfAttributeName] || gltfAttributeName.toLowerCase()

      // Skip attributes already provided by e.g. Draco extension.
      if (threeAttributeName in geometry.attributes) continue

      pending.push(assignAttributeAccessor(attributes[gltfAttributeName], threeAttributeName))
    }

    if (primitiveDef.indices !== undefined && !geometry.index) {
      var accessor = parser.getDependency('accessor', primitiveDef.indices).then(function (accessor) {
        geometry.setIndex(accessor)
      })

      pending.push(accessor)
    }

    assignExtrasToUserData(geometry, primitiveDef)

    computeBounds(geometry, primitiveDef, parser)

    return Promise.all(pending).then(function () {
      return primitiveDef.targets !== undefined ? addMorphTargets(geometry, primitiveDef.targets, parser) : geometry
    })
  }

  /**
   * @param {THREE.BufferGeometry} geometry
   * @param {Number} drawMode
   * @return {THREE.BufferGeometry}
   */
  function toTrianglesDrawMode(geometry, drawMode) {
    var index = geometry.getIndex()

    // generate index if not present

    if (index === null) {
      var indices = []

      var position = geometry.getAttribute('position')

      if (position !== undefined) {
        for (var i = 0; i < position.count; i++) {
          indices.push(i)
        }

        geometry.setIndex(indices)
        index = geometry.getIndex()
      } else {
        console.error('THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.')
        return geometry
      }
    }

    //

    var numberOfTriangles = index.count - 2
    var newIndices = []

    if (drawMode === THREE.TriangleFanDrawMode) {
      // gl.TRIANGLE_FAN

      for (var i = 1; i <= numberOfTriangles; i++) {
        newIndices.push(index.getX(0))
        newIndices.push(index.getX(i))
        newIndices.push(index.getX(i + 1))
      }
    } else {
      // gl.TRIANGLE_STRIP

      for (var i = 0; i < numberOfTriangles; i++) {
        if (i % 2 === 0) {
          newIndices.push(index.getX(i))
          newIndices.push(index.getX(i + 1))
          newIndices.push(index.getX(i + 2))
        } else {
          newIndices.push(index.getX(i + 2))
          newIndices.push(index.getX(i + 1))
          newIndices.push(index.getX(i))
        }
      }
    }

    if (newIndices.length / 3 !== numberOfTriangles) {
      console.error('THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.')
    }

    // build final geometry

    var newGeometry = geometry.clone()
    newGeometry.setIndex(newIndices)

    return newGeometry
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
   *
   * Creates BufferGeometries from primitives.
   *
   * @param {Array<GLTF.Primitive>} primitives
   * @return {Promise<Array<THREE.BufferGeometry>>}
   */
  GLTFParser.prototype.loadGeometries = function (primitives) {
    var parser = this
    var extensions = this.extensions
    var cache = this.primitiveCache

    function createDracoPrimitive(primitive) {
      return extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(primitive, parser).then(function (geometry) {
        return addPrimitiveAttributes(geometry, primitive, parser)
      })
    }

    var pending = []

    for (var i = 0, il = primitives.length; i < il; i++) {
      var primitive = primitives[i]
      var cacheKey = createPrimitiveKey(primitive)

      // See if we've already created this geometry
      var cached = cache[cacheKey]

      if (cached) {
        // Use the cached geometry if it exists
        pending.push(cached.promise)
      } else {
        var geometryPromise

        if (primitive.extensions && primitive.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]) {
          // Use DRACO geometry if available
          geometryPromise = createDracoPrimitive(primitive)
        } else {
          // Otherwise create a new geometry
          geometryPromise = addPrimitiveAttributes(new THREE.BufferGeometry(), primitive, parser)
        }

        // Cache this geometry
        cache[cacheKey] = { primitive: primitive, promise: geometryPromise }

        pending.push(geometryPromise)
      }
    }

    return Promise.all(pending)
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
   * @param {number} meshIndex
   * @return {Promise<THREE.Group|THREE.Mesh|THREE.SkinnedMesh>}
   */
  GLTFParser.prototype.loadMesh = function (meshIndex) {
    var parser = this
    var json = this.json
    var extensions = this.extensions

    var meshDef = json.meshes[meshIndex]
    var primitives = meshDef.primitives

    var pending = []

    for (var i = 0, il = primitives.length; i < il; i++) {
      var material = primitives[i].material === undefined ? createDefaultMaterial(this.cache) : this.getDependency('material', primitives[i].material)

      pending.push(material)
    }

    pending.push(parser.loadGeometries(primitives))

    return Promise.all(pending).then(function (results) {
      var materials = results.slice(0, results.length - 1)
      var geometries = results[results.length - 1]

      var meshes = []

      for (var i = 0, il = geometries.length; i < il; i++) {
        var geometry = geometries[i]
        var primitive = primitives[i]

        // 1. create Mesh

        var mesh

        var material = materials[i]

        if (
          primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
          primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
          primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
          primitive.mode === undefined
        ) {
          // .isSkinnedMesh isn't in glTF spec. See ._markDefs()
          mesh = meshDef.isSkinnedMesh === true ? new THREE.SkinnedMesh(geometry, material) : new THREE.Mesh(geometry, material)

          if (mesh.isSkinnedMesh === true && !mesh.geometry.attributes.skinWeight.normalized) {
            // we normalize floating point skin weight array to fix malformed assets (see #15319)
            // it's important to skip this for non-float32 data since normalizeSkinWeights assumes non-normalized inputs
            mesh.normalizeSkinWeights()
          }

          if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP) {
            mesh.geometry = toTrianglesDrawMode(mesh.geometry, THREE.TriangleStripDrawMode)
          } else if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN) {
            mesh.geometry = toTrianglesDrawMode(mesh.geometry, THREE.TriangleFanDrawMode)
          }
        } else if (primitive.mode === WEBGL_CONSTANTS.LINES) {
          mesh = new THREE.LineSegments(geometry, material)
        } else if (primitive.mode === WEBGL_CONSTANTS.LINE_STRIP) {
          mesh = new THREE.Line(geometry, material)
        } else if (primitive.mode === WEBGL_CONSTANTS.LINE_LOOP) {
          mesh = new THREE.LineLoop(geometry, material)
        } else if (primitive.mode === WEBGL_CONSTANTS.POINTS) {
          mesh = new THREE.Points(geometry, material)
        } else {
          throw new Error('THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode)
        }

        if (Object.keys(mesh.geometry.morphAttributes).length > 0) {
          updateMorphTargets(mesh, meshDef)
        }

        mesh.name = parser.createUniqueName(meshDef.name || 'mesh_' + meshIndex)

        assignExtrasToUserData(mesh, meshDef)

        if (primitive.extensions) addUnknownExtensionsToUserData(extensions, mesh, primitive)

        parser.assignFinalMaterial(mesh)

        meshes.push(mesh)
      }

      if (meshes.length === 1) {
        return meshes[0]
      }

      var group = new THREE.Group()

      for (var i = 0, il = meshes.length; i < il; i++) {
        group.add(meshes[i])
      }

      return group
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
   * @param {number} cameraIndex
   * @return {Promise<THREE.Camera>}
   */
  GLTFParser.prototype.loadCamera = function (cameraIndex) {
    var camera
    var cameraDef = this.json.cameras[cameraIndex]
    var params = cameraDef[cameraDef.type]

    if (!params) {
      console.warn('THREE.GLTFLoader: Missing camera parameters.')
      return
    }

    if (cameraDef.type === 'perspective') {
      camera = new THREE.PerspectiveCamera(THREE.MathUtils.radToDeg(params.yfov), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6)
    } else if (cameraDef.type === 'orthographic') {
      camera = new THREE.OrthographicCamera(-params.xmag, params.xmag, params.ymag, -params.ymag, params.znear, params.zfar)
    }

    if (cameraDef.name) camera.name = this.createUniqueName(cameraDef.name)

    assignExtrasToUserData(camera, cameraDef)

    return Promise.resolve(camera)
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
   * @param {number} skinIndex
   * @return {Promise<Object>}
   */
  GLTFParser.prototype.loadSkin = function (skinIndex) {
    var skinDef = this.json.skins[skinIndex]

    var skinEntry = { joints: skinDef.joints }

    if (skinDef.inverseBindMatrices === undefined) {
      return Promise.resolve(skinEntry)
    }

    return this.getDependency('accessor', skinDef.inverseBindMatrices).then(function (accessor) {
      skinEntry.inverseBindMatrices = accessor

      return skinEntry
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
   * @param {number} animationIndex
   * @return {Promise<THREE.AnimationClip>}
   */
  GLTFParser.prototype.loadAnimation = function (animationIndex) {
    var json = this.json

    var animationDef = json.animations[animationIndex]

    var pendingNodes = []
    var pendingInputAccessors = []
    var pendingOutputAccessors = []
    var pendingSamplers = []
    var pendingTargets = []

    for (var i = 0, il = animationDef.channels.length; i < il; i++) {
      var channel = animationDef.channels[i]
      var sampler = animationDef.samplers[channel.sampler]
      var target = channel.target
      var name = target.node !== undefined ? target.node : target.id // NOTE: target.id is deprecated.
      var input = animationDef.parameters !== undefined ? animationDef.parameters[sampler.input] : sampler.input
      var output = animationDef.parameters !== undefined ? animationDef.parameters[sampler.output] : sampler.output

      pendingNodes.push(this.getDependency('node', name))
      pendingInputAccessors.push(this.getDependency('accessor', input))
      pendingOutputAccessors.push(this.getDependency('accessor', output))
      pendingSamplers.push(sampler)
      pendingTargets.push(target)
    }

    return Promise.all([
      Promise.all(pendingNodes),
      Promise.all(pendingInputAccessors),
      Promise.all(pendingOutputAccessors),
      Promise.all(pendingSamplers),
      Promise.all(pendingTargets)
    ]).then(function (dependencies) {
      var nodes = dependencies[0]
      var inputAccessors = dependencies[1]
      var outputAccessors = dependencies[2]
      var samplers = dependencies[3]
      var targets = dependencies[4]

      var tracks = []

      for (var i = 0, il = nodes.length; i < il; i++) {
        var node = nodes[i]
        var inputAccessor = inputAccessors[i]
        var outputAccessor = outputAccessors[i]
        var sampler = samplers[i]
        var target = targets[i]

        if (node === undefined) continue

        node.updateMatrix()
        node.matrixAutoUpdate = true

        var TypedKeyframeTrack

        switch (PATH_PROPERTIES[target.path]) {
          case PATH_PROPERTIES.weights:
            TypedKeyframeTrack = THREE.NumberKeyframeTrack
            break

          case PATH_PROPERTIES.rotation:
            TypedKeyframeTrack = THREE.QuaternionKeyframeTrack
            break

          case PATH_PROPERTIES.position:
          case PATH_PROPERTIES.scale:
          default:
            TypedKeyframeTrack = THREE.VectorKeyframeTrack
            break
        }

        var targetName = node.name ? node.name : node.uuid

        var interpolation = sampler.interpolation !== undefined ? INTERPOLATION[sampler.interpolation] : THREE.InterpolateLinear

        var targetNames = []

        if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
          // Node may be a THREE.Group (glTF mesh with several primitives) or a THREE.Mesh.
          node.traverse(function (object) {
            if (object.isMesh === true && object.morphTargetInfluences) {
              targetNames.push(object.name ? object.name : object.uuid)
            }
          })
        } else {
          targetNames.push(targetName)
        }

        var outputArray = outputAccessor.array

        if (outputAccessor.normalized) {
          var scale

          if (outputArray.constructor === Int8Array) {
            scale = 1 / 127
          } else if (outputArray.constructor === Uint8Array) {
            scale = 1 / 255
          } else if (outputArray.constructor == Int16Array) {
            scale = 1 / 32767
          } else if (outputArray.constructor === Uint16Array) {
            scale = 1 / 65535
          } else {
            throw new Error('THREE.GLTFLoader: Unsupported output accessor component type.')
          }

          var scaled = new Float32Array(outputArray.length)

          for (var j = 0, jl = outputArray.length; j < jl; j++) {
            scaled[j] = outputArray[j] * scale
          }

          outputArray = scaled
        }

        for (var j = 0, jl = targetNames.length; j < jl; j++) {
          var track = new TypedKeyframeTrack(targetNames[j] + '.' + PATH_PROPERTIES[target.path], inputAccessor.array, outputArray, interpolation)

          // Override interpolation with custom factory method.
          if (sampler.interpolation === 'CUBICSPLINE') {
            track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
              // A CUBICSPLINE keyframe in glTF has three output values for each input value,
              // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
              // must be divided by three to get the interpolant's sampleSize argument.

              return new GLTFCubicSplineInterpolant(this.times, this.values, this.getValueSize() / 3, result)
            }

            // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
            track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true
          }

          tracks.push(track)
        }
      }

      var name = animationDef.name ? animationDef.name : 'animation_' + animationIndex

      return new THREE.AnimationClip(name, undefined, tracks)
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
   * @param {number} nodeIndex
   * @return {Promise<THREE.Object3D>}
   */
  GLTFParser.prototype.loadNode = function (nodeIndex) {
    var json = this.json
    var extensions = this.extensions
    var parser = this

    var nodeDef = json.nodes[nodeIndex]

    // reserve node's name before its dependencies, so the root has the intended name.
    var nodeName = nodeDef.name ? parser.createUniqueName(nodeDef.name) : ''

    return (function () {
      var pending = []

      if (nodeDef.mesh !== undefined) {
        pending.push(
          parser.getDependency('mesh', nodeDef.mesh).then(function (mesh) {
            var node = parser._getNodeRef(parser.meshCache, nodeDef.mesh, mesh)

            // if weights are provided on the node, override weights on the mesh.
            if (nodeDef.weights !== undefined) {
              node.traverse(function (o) {
                if (!o.isMesh) return

                for (var i = 0, il = nodeDef.weights.length; i < il; i++) {
                  o.morphTargetInfluences[i] = nodeDef.weights[i]
                }
              })
            }

            return node
          })
        )
      }

      if (nodeDef.camera !== undefined) {
        pending.push(
          parser.getDependency('camera', nodeDef.camera).then(function (camera) {
            return parser._getNodeRef(parser.cameraCache, nodeDef.camera, camera)
          })
        )
      }

      parser
        ._invokeAll(function (ext) {
          return ext.createNodeAttachment && ext.createNodeAttachment(nodeIndex)
        })
        .forEach(function (promise) {
          pending.push(promise)
        })

      return Promise.all(pending)
    })().then(function (objects) {
      var node

      // .isBone isn't in glTF spec. See ._markDefs
      if (nodeDef.isBone === true) {
        node = new THREE.Bone()
      } else if (objects.length > 1) {
        node = new THREE.Group()
      } else if (objects.length === 1) {
        node = objects[0]
      } else {
        node = new THREE.Object3D()
      }

      if (node !== objects[0]) {
        for (var i = 0, il = objects.length; i < il; i++) {
          node.add(objects[i])
        }
      }

      if (nodeDef.name) {
        node.userData.name = nodeDef.name
        node.name = nodeName
      }

      assignExtrasToUserData(node, nodeDef)

      if (nodeDef.extensions) addUnknownExtensionsToUserData(extensions, node, nodeDef)

      if (nodeDef.matrix !== undefined) {
        var matrix = new THREE.Matrix4()
        matrix.fromArray(nodeDef.matrix)
        node.applyMatrix4(matrix)
      } else {
        if (nodeDef.translation !== undefined) {
          node.position.fromArray(nodeDef.translation)
        }

        if (nodeDef.rotation !== undefined) {
          node.quaternion.fromArray(nodeDef.rotation)
        }

        if (nodeDef.scale !== undefined) {
          node.scale.fromArray(nodeDef.scale)
        }
      }

      parser.associations.set(node, { type: 'nodes', index: nodeIndex })

      return node
    })
  }

  /**
   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
   * @param {number} sceneIndex
   * @return {Promise<THREE.Group>}
   */
  GLTFParser.prototype.loadScene = (function () {
    // scene node hierachy builder

    function buildNodeHierachy(nodeId, parentObject, json, parser) {
      var nodeDef = json.nodes[nodeId]

      return parser
        .getDependency('node', nodeId)
        .then(function (node) {
          if (nodeDef.skin === undefined) return node

          // build skeleton here as well

          var skinEntry

          return parser
            .getDependency('skin', nodeDef.skin)
            .then(function (skin) {
              skinEntry = skin

              var pendingJoints = []

              for (var i = 0, il = skinEntry.joints.length; i < il; i++) {
                pendingJoints.push(parser.getDependency('node', skinEntry.joints[i]))
              }

              return Promise.all(pendingJoints)
            })
            .then(function (jointNodes) {
              node.traverse(function (mesh) {
                if (!mesh.isMesh) return

                var bones = []
                var boneInverses = []

                for (var j = 0, jl = jointNodes.length; j < jl; j++) {
                  var jointNode = jointNodes[j]

                  if (jointNode) {
                    bones.push(jointNode)

                    var mat = new THREE.Matrix4()

                    if (skinEntry.inverseBindMatrices !== undefined) {
                      mat.fromArray(skinEntry.inverseBindMatrices.array, j * 16)
                    }

                    boneInverses.push(mat)
                  } else {
                    console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[j])
                  }
                }

                mesh.bind(new THREE.Skeleton(bones, boneInverses), mesh.matrixWorld)
              })

              return node
            })
        })
        .then(function (node) {
          // build node hierachy

          parentObject.add(node)

          var pending = []

          if (nodeDef.children) {
            var children = nodeDef.children

            for (var i = 0, il = children.length; i < il; i++) {
              var child = children[i]
              pending.push(buildNodeHierachy(child, node, json, parser))
            }
          }

          return Promise.all(pending)
        })
    }

    return function loadScene(sceneIndex) {
      var json = this.json
      var extensions = this.extensions
      var sceneDef = this.json.scenes[sceneIndex]
      var parser = this

      // Loader returns Group, not Scene.
      // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
      var scene = new THREE.Group()
      if (sceneDef.name) scene.name = parser.createUniqueName(sceneDef.name)

      assignExtrasToUserData(scene, sceneDef)

      if (sceneDef.extensions) addUnknownExtensionsToUserData(extensions, scene, sceneDef)

      var nodeIds = sceneDef.nodes || []

      var pending = []

      for (var i = 0, il = nodeIds.length; i < il; i++) {
        pending.push(buildNodeHierachy(nodeIds[i], scene, json, parser))
      }

      return Promise.all(pending).then(function () {
        return scene
      })
    }
  })()

  return GLTFLoader
})()
THREE.SVGLoader = function (manager) {
  THREE.Loader.call(this, manager)

  // Default dots per inch
  this.defaultDPI = 90

  // Accepted units: 'mm', 'cm', 'in', 'pt', 'pc', 'px'
  this.defaultUnit = 'px'
}

THREE.SVGLoader.prototype = Object.assign(Object.create(THREE.Loader.prototype), {
  constructor: THREE.SVGLoader,

  load: function (url, onLoad, onProgress, onError) {
    var scope = this

    var loader = new THREE.FileLoader(scope.manager)
    loader.setPath(scope.path)
    loader.setRequestHeader(scope.requestHeader)
    loader.setWithCredentials(scope.withCredentials)
    loader.load(
      url,
      function (text) {
        try {
          onLoad(scope.parse(text))
        } catch (e) {
          if (onError) {
            onError(e)
          } else {
            console.error(e)
          }

          scope.manager.itemError(url)
        }
      },
      onProgress,
      onError
    )
  },

  parse: function (text) {
    var scope = this

    function parseNode(node, style) {
      if (node.nodeType !== 1) return

      var transform = getNodeTransform(node)

      var traverseChildNodes = true

      var path = null

      switch (node.nodeName) {
        case 'svg':
          break

        case 'style':
          parseCSSStylesheet(node)
          break

        case 'g':
          style = parseStyle(node, style)
          break

        case 'path':
          style = parseStyle(node, style)
          if (node.hasAttribute('d')) path = parsePathNode(node)
          break

        case 'rect':
          style = parseStyle(node, style)
          path = parseRectNode(node)
          break

        case 'polygon':
          style = parseStyle(node, style)
          path = parsePolygonNode(node)
          break

        case 'polyline':
          style = parseStyle(node, style)
          path = parsePolylineNode(node)
          break

        case 'circle':
          style = parseStyle(node, style)
          path = parseCircleNode(node)
          break

        case 'ellipse':
          style = parseStyle(node, style)
          path = parseEllipseNode(node)
          break

        case 'line':
          style = parseStyle(node, style)
          path = parseLineNode(node)
          break

        case 'defs':
          traverseChildNodes = false
          break

        case 'use':
          style = parseStyle(node, style)
          var usedNodeId = node.href.baseVal.substring(1)
          var usedNode = node.viewportElement.getElementById(usedNodeId)
          if (usedNode) {
            parseNode(usedNode, style)
          } else {
            console.warn("SVGLoader: 'use node' references non-existent node id: " + usedNodeId)
          }

          break

        default:
        // console.log( node );
      }

      if (path) {
        if (style.fill !== undefined && style.fill !== 'none') {
          path.color.setStyle(style.fill)
        }

        transformPath(path, currentTransform)

        paths.push(path)

        path.userData = { node: node, style: style }
      }

      if (traverseChildNodes) {
        var nodes = node.childNodes

        for (var i = 0; i < nodes.length; i++) {
          parseNode(nodes[i], style)
        }
      }

      if (transform) {
        transformStack.pop()

        if (transformStack.length > 0) {
          currentTransform.copy(transformStack[transformStack.length - 1])
        } else {
          currentTransform.identity()
        }
      }
    }

    function parsePathNode(node) {
      var path = new THREE.ShapePath()

      var point = new THREE.Vector2()
      var control = new THREE.Vector2()

      var firstPoint = new THREE.Vector2()
      var isFirstPoint = true
      var doSetFirstPoint = false

      var d = node.getAttribute('d')

      // console.log( d );

      var commands = d.match(/[a-df-z][^a-df-z]*/gi)

      for (var i = 0, l = commands.length; i < l; i++) {
        var command = commands[i]

        var type = command.charAt(0)
        var data = command.substr(1).trim()

        if (isFirstPoint === true) {
          doSetFirstPoint = true
          isFirstPoint = false
        }

        switch (type) {
          case 'M':
            var numbers = parseFloats(data)
            for (var j = 0, jl = numbers.length; j < jl; j += 2) {
              point.x = numbers[j + 0]
              point.y = numbers[j + 1]
              control.x = point.x
              control.y = point.y

              if (j === 0) {
                path.moveTo(point.x, point.y)
              } else {
                path.lineTo(point.x, point.y)
              }

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'H':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j++) {
              point.x = numbers[j]
              control.x = point.x
              control.y = point.y
              path.lineTo(point.x, point.y)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'V':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j++) {
              point.y = numbers[j]
              control.x = point.x
              control.y = point.y
              path.lineTo(point.x, point.y)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'L':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 2) {
              point.x = numbers[j + 0]
              point.y = numbers[j + 1]
              control.x = point.x
              control.y = point.y
              path.lineTo(point.x, point.y)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'C':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 6) {
              path.bezierCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3], numbers[j + 4], numbers[j + 5])
              control.x = numbers[j + 2]
              control.y = numbers[j + 3]
              point.x = numbers[j + 4]
              point.y = numbers[j + 5]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'S':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 4) {
              path.bezierCurveTo(getReflection(point.x, control.x), getReflection(point.y, control.y), numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
              control.x = numbers[j + 0]
              control.y = numbers[j + 1]
              point.x = numbers[j + 2]
              point.y = numbers[j + 3]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'Q':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 4) {
              path.quadraticCurveTo(numbers[j + 0], numbers[j + 1], numbers[j + 2], numbers[j + 3])
              control.x = numbers[j + 0]
              control.y = numbers[j + 1]
              point.x = numbers[j + 2]
              point.y = numbers[j + 3]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'T':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 2) {
              var rx = getReflection(point.x, control.x)
              var ry = getReflection(point.y, control.y)
              path.quadraticCurveTo(rx, ry, numbers[j + 0], numbers[j + 1])
              control.x = rx
              control.y = ry
              point.x = numbers[j + 0]
              point.y = numbers[j + 1]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'A':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 7) {
              // skip command if start point == end point
              if (numbers[j + 5] == point.x && numbers[j + 6] == point.y) continue

              var start = point.clone()
              point.x = numbers[j + 5]
              point.y = numbers[j + 6]
              control.x = point.x
              control.y = point.y
              parseArcCommand(path, numbers[j], numbers[j + 1], numbers[j + 2], numbers[j + 3], numbers[j + 4], start, point)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'm':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 2) {
              point.x += numbers[j + 0]
              point.y += numbers[j + 1]
              control.x = point.x
              control.y = point.y

              if (j === 0) {
                path.moveTo(point.x, point.y)
              } else {
                path.lineTo(point.x, point.y)
              }

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'h':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j++) {
              point.x += numbers[j]
              control.x = point.x
              control.y = point.y
              path.lineTo(point.x, point.y)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'v':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j++) {
              point.y += numbers[j]
              control.x = point.x
              control.y = point.y
              path.lineTo(point.x, point.y)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'l':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 2) {
              point.x += numbers[j + 0]
              point.y += numbers[j + 1]
              control.x = point.x
              control.y = point.y
              path.lineTo(point.x, point.y)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'c':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 6) {
              path.bezierCurveTo(
                point.x + numbers[j + 0],
                point.y + numbers[j + 1],
                point.x + numbers[j + 2],
                point.y + numbers[j + 3],
                point.x + numbers[j + 4],
                point.y + numbers[j + 5]
              )
              control.x = point.x + numbers[j + 2]
              control.y = point.y + numbers[j + 3]
              point.x += numbers[j + 4]
              point.y += numbers[j + 5]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 's':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 4) {
              path.bezierCurveTo(
                getReflection(point.x, control.x),
                getReflection(point.y, control.y),
                point.x + numbers[j + 0],
                point.y + numbers[j + 1],
                point.x + numbers[j + 2],
                point.y + numbers[j + 3]
              )
              control.x = point.x + numbers[j + 0]
              control.y = point.y + numbers[j + 1]
              point.x += numbers[j + 2]
              point.y += numbers[j + 3]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'q':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 4) {
              path.quadraticCurveTo(point.x + numbers[j + 0], point.y + numbers[j + 1], point.x + numbers[j + 2], point.y + numbers[j + 3])
              control.x = point.x + numbers[j + 0]
              control.y = point.y + numbers[j + 1]
              point.x += numbers[j + 2]
              point.y += numbers[j + 3]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 't':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 2) {
              var rx = getReflection(point.x, control.x)
              var ry = getReflection(point.y, control.y)
              path.quadraticCurveTo(rx, ry, point.x + numbers[j + 0], point.y + numbers[j + 1])
              control.x = rx
              control.y = ry
              point.x = point.x + numbers[j + 0]
              point.y = point.y + numbers[j + 1]

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'a':
            var numbers = parseFloats(data)

            for (var j = 0, jl = numbers.length; j < jl; j += 7) {
              // skip command if no displacement
              if (numbers[j + 5] == 0 && numbers[j + 6] == 0) continue

              var start = point.clone()
              point.x += numbers[j + 5]
              point.y += numbers[j + 6]
              control.x = point.x
              control.y = point.y
              parseArcCommand(path, numbers[j], numbers[j + 1], numbers[j + 2], numbers[j + 3], numbers[j + 4], start, point)

              if (j === 0 && doSetFirstPoint === true) firstPoint.copy(point)
            }

            break

          case 'Z':
          case 'z':
            path.currentPath.autoClose = true

            if (path.currentPath.curves.length > 0) {
              // Reset point to beginning of Path
              point.copy(firstPoint)
              path.currentPath.currentPoint.copy(point)
              isFirstPoint = true
            }

            break

          default:
            console.warn(command)
        }

        // console.log( type, parseFloats( data ), parseFloats( data ).length  )

        doSetFirstPoint = false
      }

      return path
    }

    function parseCSSStylesheet(node) {
      if (!node.sheet || !node.sheet.cssRules || !node.sheet.cssRules.length) return

      for (var i = 0; i < node.sheet.cssRules.length; i++) {
        var stylesheet = node.sheet.cssRules[i]

        if (stylesheet.type !== 1) continue

        var selectorList = stylesheet.selectorText
          .split(/,/gm)
          .filter(Boolean)
          .map(i => i.trim())

        for (var j = 0; j < selectorList.length; j++) {
          stylesheets[selectorList[j]] = Object.assign(stylesheets[selectorList[j]] || {}, stylesheet.style)
        }
      }
    }

    /**
     * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes
     * https://mortoray.com/2017/02/16/rendering-an-svg-elliptical-arc-as-bezier-curves/ Appendix: Endpoint to center arc conversion
     * From
     * rx ry x-axis-rotation large-arc-flag sweep-flag x y
     * To
     * aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation
     */

    function parseArcCommand(path, rx, ry, x_axis_rotation, large_arc_flag, sweep_flag, start, end) {
      if (rx == 0 || ry == 0) {
        // draw a line if either of the radii == 0
        path.lineTo(end.x, end.y)
        return
      }

      x_axis_rotation = (x_axis_rotation * Math.PI) / 180

      // Ensure radii are positive
      rx = Math.abs(rx)
      ry = Math.abs(ry)

      // Compute (x1', y1')
      var dx2 = (start.x - end.x) / 2.0
      var dy2 = (start.y - end.y) / 2.0
      var x1p = Math.cos(x_axis_rotation) * dx2 + Math.sin(x_axis_rotation) * dy2
      var y1p = -Math.sin(x_axis_rotation) * dx2 + Math.cos(x_axis_rotation) * dy2

      // Compute (cx', cy')
      var rxs = rx * rx
      var rys = ry * ry
      var x1ps = x1p * x1p
      var y1ps = y1p * y1p

      // Ensure radii are large enough
      var cr = x1ps / rxs + y1ps / rys

      if (cr > 1) {
        // scale up rx,ry equally so cr == 1
        var s = Math.sqrt(cr)
        rx = s * rx
        ry = s * ry
        rxs = rx * rx
        rys = ry * ry
      }

      var dq = rxs * y1ps + rys * x1ps
      var pq = (rxs * rys - dq) / dq
      var q = Math.sqrt(Math.max(0, pq))
      if (large_arc_flag === sweep_flag) q = -q
      var cxp = (q * rx * y1p) / ry
      var cyp = (-q * ry * x1p) / rx

      // Step 3: Compute (cx, cy) from (cx', cy')
      var cx = Math.cos(x_axis_rotation) * cxp - Math.sin(x_axis_rotation) * cyp + (start.x + end.x) / 2
      var cy = Math.sin(x_axis_rotation) * cxp + Math.cos(x_axis_rotation) * cyp + (start.y + end.y) / 2

      // Step 4: Compute θ1 and Δθ
      var theta = svgAngle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry)
      var delta = svgAngle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry) % (Math.PI * 2)

      path.currentPath.absellipse(cx, cy, rx, ry, theta, theta + delta, sweep_flag === 0, x_axis_rotation)
    }

    function svgAngle(ux, uy, vx, vy) {
      var dot = ux * vx + uy * vy
      var len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy)
      var ang = Math.acos(Math.max(-1, Math.min(1, dot / len))) // floating point precision, slightly over values appear
      if (ux * vy - uy * vx < 0) ang = -ang
      return ang
    }

    /*
     * According to https://www.w3.org/TR/SVG/shapes.html#RectElementRXAttribute
     * rounded corner should be rendered to elliptical arc, but bezier curve does the job well enough
     */
    function parseRectNode(node) {
      var x = parseFloatWithUnits(node.getAttribute('x') || 0)
      var y = parseFloatWithUnits(node.getAttribute('y') || 0)
      var rx = parseFloatWithUnits(node.getAttribute('rx') || 0)
      var ry = parseFloatWithUnits(node.getAttribute('ry') || 0)
      var w = parseFloatWithUnits(node.getAttribute('width'))
      var h = parseFloatWithUnits(node.getAttribute('height'))

      var path = new THREE.ShapePath()
      path.moveTo(x + 2 * rx, y)
      path.lineTo(x + w - 2 * rx, y)
      if (rx !== 0 || ry !== 0) path.bezierCurveTo(x + w, y, x + w, y, x + w, y + 2 * ry)
      path.lineTo(x + w, y + h - 2 * ry)
      if (rx !== 0 || ry !== 0) path.bezierCurveTo(x + w, y + h, x + w, y + h, x + w - 2 * rx, y + h)
      path.lineTo(x + 2 * rx, y + h)

      if (rx !== 0 || ry !== 0) {
        path.bezierCurveTo(x, y + h, x, y + h, x, y + h - 2 * ry)
      }

      path.lineTo(x, y + 2 * ry)

      if (rx !== 0 || ry !== 0) {
        path.bezierCurveTo(x, y, x, y, x + 2 * rx, y)
      }

      return path
    }

    function parsePolygonNode(node) {
      function iterator(match, a, b) {
        var x = parseFloatWithUnits(a)
        var y = parseFloatWithUnits(b)

        if (index === 0) {
          path.moveTo(x, y)
        } else {
          path.lineTo(x, y)
        }

        index++
      }

      var regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g

      var path = new THREE.ShapePath()

      var index = 0

      node.getAttribute('points').replace(regex, iterator)

      path.currentPath.autoClose = true

      return path
    }

    function parsePolylineNode(node) {
      function iterator(match, a, b) {
        var x = parseFloatWithUnits(a)
        var y = parseFloatWithUnits(b)

        if (index === 0) {
          path.moveTo(x, y)
        } else {
          path.lineTo(x, y)
        }

        index++
      }

      var regex = /(-?[\d\.?]+)[,|\s](-?[\d\.?]+)/g
      var path = new THREE.ShapePath()
      var index = 0
      node.getAttribute('points').replace(regex, iterator)
      path.currentPath.autoClose = false
      return path
    }

    function parseCircleNode(node) {
      var x = parseFloatWithUnits(node.getAttribute('cx'))
      var y = parseFloatWithUnits(node.getAttribute('cy'))
      var r = parseFloatWithUnits(node.getAttribute('r'))
      var subpath = new THREE.Path()
      subpath.absarc(x, y, r, 0, Math.PI * 2)
      var path = new THREE.ShapePath()
      path.subPaths.push(subpath)
      return path
    }

    function parseEllipseNode(node) {
      var x = parseFloatWithUnits(node.getAttribute('cx'))
      var y = parseFloatWithUnits(node.getAttribute('cy'))
      var rx = parseFloatWithUnits(node.getAttribute('rx'))
      var ry = parseFloatWithUnits(node.getAttribute('ry'))
      var subpath = new THREE.Path()
      subpath.absellipse(x, y, rx, ry, 0, Math.PI * 2)
      var path = new THREE.ShapePath()
      path.subPaths.push(subpath)
      return path
    }

    function parseLineNode(node) {
      var x1 = parseFloatWithUnits(node.getAttribute('x1'))
      var y1 = parseFloatWithUnits(node.getAttribute('y1'))
      var x2 = parseFloatWithUnits(node.getAttribute('x2'))
      var y2 = parseFloatWithUnits(node.getAttribute('y2'))
      var path = new THREE.ShapePath()
      path.moveTo(x1, y1)
      path.lineTo(x2, y2)
      path.currentPath.autoClose = false
      return path
    }
    function parseStyle(node, style) {
      style = Object.assign({}, style) // clone style

      var stylesheetStyles = {}

      if (node.hasAttribute('class')) {
        var classSelectors = node
          .getAttribute('class')
          .split(/\s/)
          .filter(Boolean)
          .map(i => i.trim())

        for (var i = 0; i < classSelectors.length; i++) {
          stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['.' + classSelectors[i]])
        }
      }

      if (node.hasAttribute('id')) {
        stylesheetStyles = Object.assign(stylesheetStyles, stylesheets['#' + node.getAttribute('id')])
      }

      function addStyle(svgName, jsName, adjustFunction) {
        if (adjustFunction === undefined)
          adjustFunction = function copy(v) {
            if (v.startsWith('url')) console.warn('SVGLoader: url access in attributes is not implemented.')

            return v
          }

        if (node.hasAttribute(svgName)) style[jsName] = adjustFunction(node.getAttribute(svgName))
        if (stylesheetStyles[svgName]) style[jsName] = adjustFunction(stylesheetStyles[svgName])
        if (node.style && node.style[svgName] !== '') style[jsName] = adjustFunction(node.style[svgName])
      }

      function clamp(v) {
        return Math.max(0, Math.min(1, parseFloatWithUnits(v)))
      }

      function positive(v) {
        return Math.max(0, parseFloatWithUnits(v))
      }

      addStyle('fill', 'fill')
      addStyle('fill-opacity', 'fillOpacity', clamp)
      addStyle('opacity', 'opacity', clamp)
      addStyle('stroke', 'stroke')
      addStyle('stroke-opacity', 'strokeOpacity', clamp)
      addStyle('stroke-width', 'strokeWidth', positive)
      addStyle('stroke-linejoin', 'strokeLineJoin')
      addStyle('stroke-linecap', 'strokeLineCap')
      addStyle('stroke-miterlimit', 'strokeMiterLimit', positive)
      addStyle('visibility', 'visibility')

      return style
    }

    // http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes

    function getReflection(a, b) {
      return a - (b - a)
    }

    function parseFloats(string) {
      var array = string.split(/[\s,]+|(?=\s?[+\-])/)

      for (var i = 0; i < array.length; i++) {
        var number = array[i]

        // Handle values like 48.6037.7.8
        // TODO Find a regex for this

        if (number.indexOf('.') !== number.lastIndexOf('.')) {
          var split = number.split('.')

          for (var s = 2; s < split.length; s++) {
            array.splice(i + s - 1, 0, '0.' + split[s])
          }
        }

        array[i] = parseFloatWithUnits(number)
      }

      return array
    }

    // Units

    var units = ['mm', 'cm', 'in', 'pt', 'pc', 'px']

    // Conversion: [ fromUnit ][ toUnit ] (-1 means dpi dependent)
    var unitConversion = {
      mm: {
        mm: 1,
        cm: 0.1,
        in: 1 / 25.4,
        pt: 72 / 25.4,
        pc: 6 / 25.4,
        px: -1
      },
      cm: {
        mm: 10,
        cm: 1,
        in: 1 / 2.54,
        pt: 72 / 2.54,
        pc: 6 / 2.54,
        px: -1
      },
      in: {
        mm: 25.4,
        cm: 2.54,
        in: 1,
        pt: 72,
        pc: 6,
        px: -1
      },
      pt: {
        mm: 25.4 / 72,
        cm: 2.54 / 72,
        in: 1 / 72,
        pt: 1,
        pc: 6 / 72,
        px: -1
      },
      pc: {
        mm: 25.4 / 6,
        cm: 2.54 / 6,
        in: 1 / 6,
        pt: 72 / 6,
        pc: 1,
        px: -1
      },
      px: {
        px: 1
      }
    }

    function parseFloatWithUnits(string) {
      var theUnit = 'px'

      if (typeof string === 'string' || string instanceof String) {
        for (var i = 0, n = units.length; i < n; i++) {
          var u = units[i]

          if (string.endsWith(u)) {
            theUnit = u
            string = string.substring(0, string.length - u.length)
            break
          }
        }
      }

      var scale = undefined

      if (theUnit === 'px' && scope.defaultUnit !== 'px') {
        // Conversion scale from  pixels to inches, then to default units

        scale = unitConversion['in'][scope.defaultUnit] / scope.defaultDPI
      } else {
        scale = unitConversion[theUnit][scope.defaultUnit]

        if (scale < 0) {
          // Conversion scale to pixels

          scale = unitConversion[theUnit]['in'] * scope.defaultDPI
        }
      }

      return scale * parseFloat(string)
    }

    // Transforms

    function getNodeTransform(node) {
      if (!(node.hasAttribute('transform') || (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))))) {
        return null
      }

      var transform = parseNodeTransform(node)

      if (transformStack.length > 0) {
        transform.premultiply(transformStack[transformStack.length - 1])
      }

      currentTransform.copy(transform)
      transformStack.push(transform)

      return transform
    }

    function parseNodeTransform(node) {
      var transform = new THREE.Matrix3()
      var currentTransform = tempTransform0

      if (node.nodeName === 'use' && (node.hasAttribute('x') || node.hasAttribute('y'))) {
        var tx = parseFloatWithUnits(node.getAttribute('x'))
        var ty = parseFloatWithUnits(node.getAttribute('y'))

        transform.translate(tx, ty)
      }

      if (node.hasAttribute('transform')) {
        var transformsTexts = node.getAttribute('transform').split(')')

        for (var tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
          var transformText = transformsTexts[tIndex].trim()

          if (transformText === '') continue

          var openParPos = transformText.indexOf('(')
          var closeParPos = transformText.length

          if (openParPos > 0 && openParPos < closeParPos) {
            var transformType = transformText.substr(0, openParPos)

            var array = parseFloats(transformText.substr(openParPos + 1, closeParPos - openParPos - 1))

            currentTransform.identity()

            switch (transformType) {
              case 'translate':
                if (array.length >= 1) {
                  var tx = array[0]
                  var ty = tx

                  if (array.length >= 2) {
                    ty = array[1]
                  }

                  currentTransform.translate(tx, ty)
                }

                break

              case 'rotate':
                if (array.length >= 1) {
                  var angle = 0
                  var cx = 0
                  var cy = 0

                  // Angle
                  angle = (-array[0] * Math.PI) / 180

                  if (array.length >= 3) {
                    // Center x, y
                    cx = array[1]
                    cy = array[2]
                  }

                  // Rotate around center (cx, cy)
                  tempTransform1.identity().translate(-cx, -cy)
                  tempTransform2.identity().rotate(angle)
                  tempTransform3.multiplyMatrices(tempTransform2, tempTransform1)
                  tempTransform1.identity().translate(cx, cy)
                  currentTransform.multiplyMatrices(tempTransform1, tempTransform3)
                }

                break

              case 'scale':
                if (array.length >= 1) {
                  var scaleX = array[0]
                  var scaleY = scaleX

                  if (array.length >= 2) {
                    scaleY = array[1]
                  }

                  currentTransform.scale(scaleX, scaleY)
                }

                break

              case 'skewX':
                if (array.length === 1) {
                  currentTransform.set(1, Math.tan((array[0] * Math.PI) / 180), 0, 0, 1, 0, 0, 0, 1)
                }

                break

              case 'skewY':
                if (array.length === 1) {
                  currentTransform.set(1, 0, 0, Math.tan((array[0] * Math.PI) / 180), 1, 0, 0, 0, 1)
                }

                break

              case 'matrix':
                if (array.length === 6) {
                  currentTransform.set(array[0], array[2], array[4], array[1], array[3], array[5], 0, 0, 1)
                }

                break
            }
          }

          transform.premultiply(currentTransform)
        }
      }

      return transform
    }

    function transformPath(path, m) {
      function transfVec2(v2) {
        tempV3.set(v2.x, v2.y, 1).applyMatrix3(m)

        v2.set(tempV3.x, tempV3.y)
      }

      var isRotated = isTransformRotated(m)

      var subPaths = path.subPaths

      for (var i = 0, n = subPaths.length; i < n; i++) {
        var subPath = subPaths[i]
        var curves = subPath.curves

        for (var j = 0; j < curves.length; j++) {
          var curve = curves[j]

          if (curve.isLineCurve) {
            transfVec2(curve.v1)
            transfVec2(curve.v2)
          } else if (curve.isCubicBezierCurve) {
            transfVec2(curve.v0)
            transfVec2(curve.v1)
            transfVec2(curve.v2)
            transfVec2(curve.v3)
          } else if (curve.isQuadraticBezierCurve) {
            transfVec2(curve.v0)
            transfVec2(curve.v1)
            transfVec2(curve.v2)
          } else if (curve.isEllipseCurve) {
            if (isRotated) {
              console.warn('SVGLoader: Elliptic arc or ellipse rotation or skewing is not implemented.')
            }

            tempV2.set(curve.aX, curve.aY)
            transfVec2(tempV2)
            curve.aX = tempV2.x
            curve.aY = tempV2.y

            curve.xRadius *= getTransformScaleX(m)
            curve.yRadius *= getTransformScaleY(m)
          }
        }
      }
    }

    function isTransformRotated(m) {
      return m.elements[1] !== 0 || m.elements[3] !== 0
    }

    function getTransformScaleX(m) {
      var te = m.elements
      return Math.sqrt(te[0] * te[0] + te[1] * te[1])
    }

    function getTransformScaleY(m) {
      var te = m.elements
      return Math.sqrt(te[3] * te[3] + te[4] * te[4])
    }

    //

    var paths = []
    var stylesheets = {}

    var transformStack = []

    var tempTransform0 = new THREE.Matrix3()
    var tempTransform1 = new THREE.Matrix3()
    var tempTransform2 = new THREE.Matrix3()
    var tempTransform3 = new THREE.Matrix3()
    var tempV2 = new THREE.Vector2()
    var tempV3 = new THREE.Vector3()

    var currentTransform = new THREE.Matrix3()

    var xml = new DOMParser().parseFromString(text, 'image/svg+xml') // application/xml

    parseNode(xml.documentElement, {
      fill: '#000',
      fillOpacity: 1,
      strokeOpacity: 1,
      strokeWidth: 1,
      strokeLineJoin: 'miter',
      strokeLineCap: 'butt',
      strokeMiterLimit: 4
    })

    var data = { paths: paths, xml: xml.documentElement }

    // console.log( paths );
    return data
  }
})

THREE.SVGLoader.getStrokeStyle = function (width, color, lineJoin, lineCap, miterLimit) {
  // Param width: Stroke width
  // Param color: As returned by THREE.Color.getStyle()
  // Param lineJoin: One of "round", "bevel", "miter" or "miter-limit"
  // Param lineCap: One of "round", "square" or "butt"
  // Param miterLimit: Maximum join length, in multiples of the "width" parameter (join is truncated if it exceeds that distance)
  // Returns style object

  width = width !== undefined ? width : 1
  color = color !== undefined ? color : '#000'
  lineJoin = lineJoin !== undefined ? lineJoin : 'miter'
  lineCap = lineCap !== undefined ? lineCap : 'butt'
  miterLimit = miterLimit !== undefined ? miterLimit : 4

  return {
    strokeColor: color,
    strokeWidth: width,
    strokeLineJoin: lineJoin,
    strokeLineCap: lineCap,
    strokeMiterLimit: miterLimit
  }
}

THREE.SVGLoader.pointsToStroke = function (points, style, arcDivisions, minDistance) {
  // Generates a stroke with some witdh around the given path.
  // The path can be open or closed (last point equals to first point)
  // Param points: Array of Vector2D (the path). Minimum 2 points.
  // Param style: Object with SVG properties as returned by SVGLoader.getStrokeStyle(), or SVGLoader.parse() in the path.userData.style object
  // Params arcDivisions: Arc divisions for round joins and endcaps. (Optional)
  // Param minDistance: Points closer to this distance will be merged. (Optional)
  // Returns BufferGeometry with stroke triangles (In plane z = 0). UV coordinates are generated ('u' along path. 'v' across it, from left to right)

  var vertices = []
  var normals = []
  var uvs = []

  if (THREE.SVGLoader.pointsToStrokeWithBuffers(points, style, arcDivisions, minDistance, vertices, normals, uvs) === 0) {
    return null
  }

  var geometry = new THREE.BufferGeometry()
  geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3))
  geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3))
  geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2))

  return geometry
}

THREE.SVGLoader.pointsToStrokeWithBuffers = (function () {
  var tempV2_1 = new THREE.Vector2()
  var tempV2_2 = new THREE.Vector2()
  var tempV2_3 = new THREE.Vector2()
  var tempV2_4 = new THREE.Vector2()
  var tempV2_5 = new THREE.Vector2()
  var tempV2_6 = new THREE.Vector2()
  var tempV2_7 = new THREE.Vector2()
  var lastPointL = new THREE.Vector2()
  var lastPointR = new THREE.Vector2()
  var point0L = new THREE.Vector2()
  var point0R = new THREE.Vector2()
  var currentPointL = new THREE.Vector2()
  var currentPointR = new THREE.Vector2()
  var nextPointL = new THREE.Vector2()
  var nextPointR = new THREE.Vector2()
  var innerPoint = new THREE.Vector2()
  var outerPoint = new THREE.Vector2()

  return function (points, style, arcDivisions, minDistance, vertices, normals, uvs, vertexOffset) {
    // This function can be called to update existing arrays or buffers.
    // Accepts same parameters as pointsToStroke, plus the buffers and optional offset.
    // Param vertexOffset: Offset vertices to start writing in the buffers (3 elements/vertex for vertices and normals, and 2 elements/vertex for uvs)
    // Returns number of written vertices / normals / uvs pairs
    // if 'vertices' parameter is undefined no triangles will be generated, but the returned vertices count will still be valid (useful to preallocate the buffers)
    // 'normals' and 'uvs' buffers are optional

    arcDivisions = arcDivisions !== undefined ? arcDivisions : 12
    minDistance = minDistance !== undefined ? minDistance : 0.001
    vertexOffset = vertexOffset !== undefined ? vertexOffset : 0

    // First ensure there are no duplicated points
    points = removeDuplicatedPoints(points)

    var numPoints = points.length

    if (numPoints < 2) return 0

    var isClosed = points[0].equals(points[numPoints - 1])

    var currentPoint
    var previousPoint = points[0]
    var nextPoint

    var strokeWidth2 = style.strokeWidth / 2

    var deltaU = 1 / (numPoints - 1)
    var u0 = 0

    var innerSideModified
    var joinIsOnLeftSide
    var isMiter
    var initialJoinIsOnLeftSide = false

    var numVertices = 0
    var currentCoordinate = vertexOffset * 3
    var currentCoordinateUV = vertexOffset * 2

    // Get initial left and right stroke points
    getNormal(points[0], points[1], tempV2_1).multiplyScalar(strokeWidth2)
    lastPointL.copy(points[0]).sub(tempV2_1)
    lastPointR.copy(points[0]).add(tempV2_1)
    point0L.copy(lastPointL)
    point0R.copy(lastPointR)

    for (var iPoint = 1; iPoint < numPoints; iPoint++) {
      currentPoint = points[iPoint]

      // Get next point
      if (iPoint === numPoints - 1) {
        if (isClosed) {
          // Skip duplicated initial point
          nextPoint = points[1]
        } else nextPoint = undefined
      } else {
        nextPoint = points[iPoint + 1]
      }

      // Normal of previous segment in tempV2_1
      var normal1 = tempV2_1
      getNormal(previousPoint, currentPoint, normal1)

      tempV2_3.copy(normal1).multiplyScalar(strokeWidth2)
      currentPointL.copy(currentPoint).sub(tempV2_3)
      currentPointR.copy(currentPoint).add(tempV2_3)

      var u1 = u0 + deltaU

      innerSideModified = false

      if (nextPoint !== undefined) {
        // Normal of next segment in tempV2_2
        getNormal(currentPoint, nextPoint, tempV2_2)

        tempV2_3.copy(tempV2_2).multiplyScalar(strokeWidth2)
        nextPointL.copy(currentPoint).sub(tempV2_3)
        nextPointR.copy(currentPoint).add(tempV2_3)

        joinIsOnLeftSide = true
        tempV2_3.subVectors(nextPoint, previousPoint)
        if (normal1.dot(tempV2_3) < 0) {
          joinIsOnLeftSide = false
        }

        if (iPoint === 1) initialJoinIsOnLeftSide = joinIsOnLeftSide

        tempV2_3.subVectors(nextPoint, currentPoint)
        tempV2_3.normalize()
        var dot = Math.abs(normal1.dot(tempV2_3))

        // If path is straight, don't create join
        if (dot !== 0) {
          // Compute inner and outer segment intersections
          var miterSide = strokeWidth2 / dot
          tempV2_3.multiplyScalar(-miterSide)
          tempV2_4.subVectors(currentPoint, previousPoint)
          tempV2_5.copy(tempV2_4).setLength(miterSide).add(tempV2_3)
          innerPoint.copy(tempV2_5).negate()
          var miterLength2 = tempV2_5.length()
          var segmentLengthPrev = tempV2_4.length()
          tempV2_4.divideScalar(segmentLengthPrev)
          tempV2_6.subVectors(nextPoint, currentPoint)
          var segmentLengthNext = tempV2_6.length()
          tempV2_6.divideScalar(segmentLengthNext)
          // Check that previous and next segments doesn't overlap with the innerPoint of intersection
          if (tempV2_4.dot(innerPoint) < segmentLengthPrev && tempV2_6.dot(innerPoint) < segmentLengthNext) {
            innerSideModified = true
          }

          outerPoint.copy(tempV2_5).add(currentPoint)
          innerPoint.add(currentPoint)

          isMiter = false

          if (innerSideModified) {
            if (joinIsOnLeftSide) {
              nextPointR.copy(innerPoint)
              currentPointR.copy(innerPoint)
            } else {
              nextPointL.copy(innerPoint)
              currentPointL.copy(innerPoint)
            }
          } else {
            // The segment triangles are generated here if there was overlapping

            makeSegmentTriangles()
          }

          switch (style.strokeLineJoin) {
            case 'bevel':
              makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)

              break

            case 'round':
              // Segment triangles

              createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)

              // Join triangles

              if (joinIsOnLeftSide) {
                makeCircularSector(currentPoint, currentPointL, nextPointL, u1, 0)
              } else {
                makeCircularSector(currentPoint, nextPointR, currentPointR, u1, 1)
              }

              break

            case 'miter':
            case 'miter-clip':
            default:
              var miterFraction = (strokeWidth2 * style.strokeMiterLimit) / miterLength2

              if (miterFraction < 1) {
                // The join miter length exceeds the miter limit

                if (style.strokeLineJoin !== 'miter-clip') {
                  makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u1)
                  break
                } else {
                  // Segment triangles

                  createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified)

                  // Miter-clip join triangles

                  if (joinIsOnLeftSide) {
                    tempV2_6.subVectors(outerPoint, currentPointL).multiplyScalar(miterFraction).add(currentPointL)
                    tempV2_7.subVectors(outerPoint, nextPointL).multiplyScalar(miterFraction).add(nextPointL)

                    addVertex(currentPointL, u1, 0)
                    addVertex(tempV2_6, u1, 0)
                    addVertex(currentPoint, u1, 0.5)

                    addVertex(currentPoint, u1, 0.5)
                    addVertex(tempV2_6, u1, 0)
                    addVertex(tempV2_7, u1, 0)

                    addVertex(currentPoint, u1, 0.5)
                    addVertex(tempV2_7, u1, 0)
                    addVertex(nextPointL, u1, 0)
                  } else {
                    tempV2_6.subVectors(outerPoint, currentPointR).multiplyScalar(miterFraction).add(currentPointR)
                    tempV2_7.subVectors(outerPoint, nextPointR).multiplyScalar(miterFraction).add(nextPointR)

                    addVertex(currentPointR, u1, 1)
                    addVertex(tempV2_6, u1, 1)
                    addVertex(currentPoint, u1, 0.5)

                    addVertex(currentPoint, u1, 0.5)
                    addVertex(tempV2_6, u1, 1)
                    addVertex(tempV2_7, u1, 1)

                    addVertex(currentPoint, u1, 0.5)
                    addVertex(tempV2_7, u1, 1)
                    addVertex(nextPointR, u1, 1)
                  }
                }
              } else {
                // Miter join segment triangles

                if (innerSideModified) {
                  // Optimized segment + join triangles

                  if (joinIsOnLeftSide) {
                    addVertex(lastPointR, u0, 1)
                    addVertex(lastPointL, u0, 0)
                    addVertex(outerPoint, u1, 0)

                    addVertex(lastPointR, u0, 1)
                    addVertex(outerPoint, u1, 0)
                    addVertex(innerPoint, u1, 1)
                  } else {
                    addVertex(lastPointR, u0, 1)
                    addVertex(lastPointL, u0, 0)
                    addVertex(outerPoint, u1, 1)

                    addVertex(lastPointL, u0, 0)
                    addVertex(innerPoint, u1, 0)
                    addVertex(outerPoint, u1, 1)
                  }

                  if (joinIsOnLeftSide) {
                    nextPointL.copy(outerPoint)
                  } else {
                    nextPointR.copy(outerPoint)
                  }
                } else {
                  // Add extra miter join triangles

                  if (joinIsOnLeftSide) {
                    addVertex(currentPointL, u1, 0)
                    addVertex(outerPoint, u1, 0)
                    addVertex(currentPoint, u1, 0.5)

                    addVertex(currentPoint, u1, 0.5)
                    addVertex(outerPoint, u1, 0)
                    addVertex(nextPointL, u1, 0)
                  } else {
                    addVertex(currentPointR, u1, 1)
                    addVertex(outerPoint, u1, 1)
                    addVertex(currentPoint, u1, 0.5)

                    addVertex(currentPoint, u1, 0.5)
                    addVertex(outerPoint, u1, 1)
                    addVertex(nextPointR, u1, 1)
                  }
                }

                isMiter = true
              }

              break
          }
        } else {
          // The segment triangles are generated here when two consecutive points are collinear

          makeSegmentTriangles()
        }
      } else {
        // The segment triangles are generated here if it is the ending segment

        makeSegmentTriangles()
      }

      if (!isClosed && iPoint === numPoints - 1) {
        // Start line endcap
        addCapGeometry(points[0], point0L, point0R, joinIsOnLeftSide, true, u0)
      }

      // Increment loop variables

      u0 = u1

      previousPoint = currentPoint

      lastPointL.copy(nextPointL)
      lastPointR.copy(nextPointR)
    }

    if (!isClosed) {
      // Ending line endcap
      addCapGeometry(currentPoint, currentPointL, currentPointR, joinIsOnLeftSide, false, u1)
    } else if (innerSideModified && vertices) {
      // Modify path first segment vertices to adjust to the segments inner and outer intersections

      var lastOuter = outerPoint
      var lastInner = innerPoint

      if (initialJoinIsOnLeftSide !== joinIsOnLeftSide) {
        lastOuter = innerPoint
        lastInner = outerPoint
      }

      if (joinIsOnLeftSide) {
        if (isMiter || initialJoinIsOnLeftSide) {
          lastInner.toArray(vertices, 0 * 3)
          lastInner.toArray(vertices, 3 * 3)

          if (isMiter) {
            lastOuter.toArray(vertices, 1 * 3)
          }
        }
      } else {
        if (isMiter || !initialJoinIsOnLeftSide) {
          lastInner.toArray(vertices, 1 * 3)
          lastInner.toArray(vertices, 3 * 3)

          if (isMiter) {
            lastOuter.toArray(vertices, 0 * 3)
          }
        }
      }
    }

    return numVertices

    // -- End of algorithm

    // -- Functions

    function getNormal(p1, p2, result) {
      result.subVectors(p2, p1)
      return result.set(-result.y, result.x).normalize()
    }

    function addVertex(position, u, v) {
      if (vertices) {
        vertices[currentCoordinate] = position.x
        vertices[currentCoordinate + 1] = position.y
        vertices[currentCoordinate + 2] = 0

        if (normals) {
          normals[currentCoordinate] = 0
          normals[currentCoordinate + 1] = 0
          normals[currentCoordinate + 2] = 1
        }

        currentCoordinate += 3

        if (uvs) {
          uvs[currentCoordinateUV] = u
          uvs[currentCoordinateUV + 1] = v

          currentCoordinateUV += 2
        }
      }

      numVertices += 3
    }

    function makeCircularSector(center, p1, p2, u, v) {
      // param p1, p2: Points in the circle arc.
      // p1 and p2 are in clockwise direction.

      tempV2_1.copy(p1).sub(center).normalize()
      tempV2_2.copy(p2).sub(center).normalize()

      var angle = Math.PI
      var dot = tempV2_1.dot(tempV2_2)
      if (Math.abs(dot) < 1) angle = Math.abs(Math.acos(dot))

      angle /= arcDivisions

      tempV2_3.copy(p1)

      for (var i = 0, il = arcDivisions - 1; i < il; i++) {
        tempV2_4.copy(tempV2_3).rotateAround(center, angle)

        addVertex(tempV2_3, u, v)
        addVertex(tempV2_4, u, v)
        addVertex(center, u, 0.5)

        tempV2_3.copy(tempV2_4)
      }

      addVertex(tempV2_4, u, v)
      addVertex(p2, u, v)
      addVertex(center, u, 0.5)
    }

    function makeSegmentTriangles() {
      addVertex(lastPointR, u0, 1)
      addVertex(lastPointL, u0, 0)
      addVertex(currentPointL, u1, 0)

      addVertex(lastPointR, u0, 1)
      addVertex(currentPointL, u1, 1)
      addVertex(currentPointR, u1, 0)
    }

    function makeSegmentWithBevelJoin(joinIsOnLeftSide, innerSideModified, u) {
      if (innerSideModified) {
        // Optimized segment + bevel triangles

        if (joinIsOnLeftSide) {
          // Path segments triangles

          addVertex(lastPointR, u0, 1)
          addVertex(lastPointL, u0, 0)
          addVertex(currentPointL, u1, 0)

          addVertex(lastPointR, u0, 1)
          addVertex(currentPointL, u1, 0)
          addVertex(innerPoint, u1, 1)

          // Bevel join triangle

          addVertex(currentPointL, u, 0)
          addVertex(nextPointL, u, 0)
          addVertex(innerPoint, u, 0.5)
        } else {
          // Path segments triangles

          addVertex(lastPointR, u0, 1)
          addVertex(lastPointL, u0, 0)
          addVertex(currentPointR, u1, 1)

          addVertex(lastPointL, u0, 0)
          addVertex(innerPoint, u1, 0)
          addVertex(currentPointR, u1, 1)

          // Bevel join triangle

          addVertex(currentPointR, u, 1)
          addVertex(nextPointR, u, 0)
          addVertex(innerPoint, u, 0.5)
        }
      } else {
        // Bevel join triangle. The segment triangles are done in the main loop

        if (joinIsOnLeftSide) {
          addVertex(currentPointL, u, 0)
          addVertex(nextPointL, u, 0)
          addVertex(currentPoint, u, 0.5)
        } else {
          addVertex(currentPointR, u, 1)
          addVertex(nextPointR, u, 0)
          addVertex(currentPoint, u, 0.5)
        }
      }
    }

    function createSegmentTrianglesWithMiddleSection(joinIsOnLeftSide, innerSideModified) {
      if (innerSideModified) {
        if (joinIsOnLeftSide) {
          addVertex(lastPointR, u0, 1)
          addVertex(lastPointL, u0, 0)
          addVertex(currentPointL, u1, 0)

          addVertex(lastPointR, u0, 1)
          addVertex(currentPointL, u1, 0)
          addVertex(innerPoint, u1, 1)

          addVertex(currentPointL, u0, 0)
          addVertex(currentPoint, u1, 0.5)
          addVertex(innerPoint, u1, 1)

          addVertex(currentPoint, u1, 0.5)
          addVertex(nextPointL, u0, 0)
          addVertex(innerPoint, u1, 1)
        } else {
          addVertex(lastPointR, u0, 1)
          addVertex(lastPointL, u0, 0)
          addVertex(currentPointR, u1, 1)

          addVertex(lastPointL, u0, 0)
          addVertex(innerPoint, u1, 0)
          addVertex(currentPointR, u1, 1)

          addVertex(currentPointR, u0, 1)
          addVertex(innerPoint, u1, 0)
          addVertex(currentPoint, u1, 0.5)

          addVertex(currentPoint, u1, 0.5)
          addVertex(innerPoint, u1, 0)
          addVertex(nextPointR, u0, 1)
        }
      }
    }

    function addCapGeometry(center, p1, p2, joinIsOnLeftSide, start, u) {
      // param center: End point of the path
      // param p1, p2: Left and right cap points

      switch (style.strokeLineCap) {
        case 'round':
          if (start) {
            makeCircularSector(center, p2, p1, u, 0.5)
          } else {
            makeCircularSector(center, p1, p2, u, 0.5)
          }

          break

        case 'square':
          if (start) {
            tempV2_1.subVectors(p1, center)
            tempV2_2.set(tempV2_1.y, -tempV2_1.x)

            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)

            // Modify already existing vertices
            if (joinIsOnLeftSide) {
              tempV2_3.toArray(vertices, 1 * 3)
              tempV2_4.toArray(vertices, 0 * 3)
              tempV2_4.toArray(vertices, 3 * 3)
            } else {
              tempV2_3.toArray(vertices, 1 * 3)
              tempV2_3.toArray(vertices, 3 * 3)
              tempV2_4.toArray(vertices, 0 * 3)
            }
          } else {
            tempV2_1.subVectors(p2, center)
            tempV2_2.set(tempV2_1.y, -tempV2_1.x)

            tempV2_3.addVectors(tempV2_1, tempV2_2).add(center)
            tempV2_4.subVectors(tempV2_2, tempV2_1).add(center)

            var vl = vertices.length

            // Modify already existing vertices
            if (joinIsOnLeftSide) {
              tempV2_3.toArray(vertices, vl - 1 * 3)
              tempV2_4.toArray(vertices, vl - 2 * 3)
              tempV2_4.toArray(vertices, vl - 4 * 3)
            } else {
              tempV2_3.toArray(vertices, vl - 2 * 3)
              tempV2_4.toArray(vertices, vl - 1 * 3)
              tempV2_4.toArray(vertices, vl - 4 * 3)
            }
          }

          break

        case 'butt':
        default:
          // Nothing to do here
          break
      }
    }

    function removeDuplicatedPoints(points) {
      // Creates a new array if necessary with duplicated points removed.
      // This does not remove duplicated initial and ending points of a closed path.

      var dupPoints = false
      for (var i = 1, n = points.length - 1; i < n; i++) {
        if (points[i].distanceTo(points[i + 1]) < minDistance) {
          dupPoints = true
          break
        }
      }

      if (!dupPoints) return points

      var newPoints = []
      newPoints.push(points[0])

      for (var i = 1, n = points.length - 1; i < n; i++) {
        if (points[i].distanceTo(points[i + 1]) >= minDistance) {
          newPoints.push(points[i])
        }
      }

      newPoints.push(points[points.length - 1])

      return newPoints
    }
  }
})()

/////////////////------------------------------------    OrbitControls     --------------
THREE.OrbitControls = function (object, domElement) {
  this.object = object

  this.domElement = domElement !== undefined ? domElement : document

  // Set to false to disable this control
  this.enabled = true

  // "target" sets the location of focus, where the object orbits around
  this.target = new THREE.Vector3()

  // How far you can dolly in and out ( PerspectiveCamera only )
  this.minDistance = 0
  this.maxDistance = Infinity

  // How far you can zoom in and out ( OrthographicCamera only )
  this.minZoom = 0
  this.maxZoom = Infinity

  // How far you can orbit vertically, upper and lower limits.
  // Range is 0 to Math.PI radians.
  this.minPolarAngle = 0 // radians
  this.maxPolarAngle = Math.PI // radians

  // How far you can orbit horizontally, upper and lower limits.
  // If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].
  this.minAzimuthAngle = -Infinity // radians
  this.maxAzimuthAngle = Infinity // radians

  // Set to true to enable damping (inertia)
  // If damping is enabled, you must call controls.update() in your animation loop
  this.enableDamping = false
  this.dampingFactor = 0.05

  // This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
  // Set to false to disable zooming
  this.enableZoom = true
  this.zoomSpeed = 1.0

  // Set to false to disable rotating
  this.enableRotate = true
  this.rotateSpeed = 1.0

  // Set to false to disable panning
  this.enablePan = true
  this.panSpeed = 1.0
  this.screenSpacePanning = false // if true, pan in screen-space
  this.keyPanSpeed = 7.0 // pixels moved per arrow key push

  // Set to true to automatically rotate around the target
  // If auto-rotate is enabled, you must call controls.update() in your animation loop
  this.autoRotate = false
  this.autoRotateSpeed = 2.0 // 30 seconds per round when fps is 60

  // Set to false to disable use of the keys
  this.enableKeys = true

  // The four arrow keys
  this.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 }

  this.minPan = null

  this.maxPan = null

  // Mouse buttons
  this.mouseButtons = {
    LEFT: THREE.MOUSE.ROTATE,
    MIDDLE: THREE.MOUSE.DOLLY,
    RIGHT: THREE.MOUSE.PAN
  }

  // Touch fingers
  this.touches = { ONE: THREE.TOUCH.ROTATE, TWO: THREE.TOUCH.DOLLY_PAN }

  // for reset
  this.target0 = this.target.clone()
  this.position0 = this.object.position.clone()
  this.zoom0 = this.object.zoom
  this.scale = 1
  //
  // public methods
  //
  //设置远近
  this.getDistance = function () {
    return spherical.radius
  }
  //设置远近
  this.setDistance = function (distance) {
    if (distance > spherical.radius) {
      dollyOut(distance / spherical.radius)
    } else {
      dollyIn(spherical.radius / distance)
    }
  }
  this.setPanCenter = function () {
    panOffset = new THREE.Vector3()
  }
  //获取垂直旋转角度
  this.getRotate = function () {
    return spherical.phi
  }
  //垂直旋转角度
  this.rotate = function (angle) {
    sphericalDelta.phi -= angle
  }
  //设置水平旋转角度
  this.setRotateHorizontal = function (angle) {
    sphericalDelta.theta -= angle
  }
  //获取水平旋转角度
  this.getRotateHorizontal = function () {
    return spherical.theta
  }
  //设置ZOOM
  this.setZoom = function (zoom) {
    this.zoom0 = zoom
    scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, zoom))
    scope.object.updateProjectionMatrix()
    zoomChanged = true
  }

  this.getPolarAngle = function () {
    return spherical.phi
  }

  this.getAzimuthalAngle = function () {
    return spherical.theta
  }

  this.saveState = function () {
    scope.target0.copy(scope.target)
    scope.position0.copy(scope.object.position)
    scope.zoom0 = scope.object.zoom
  }

  this.reset = function () {
    scope.target.copy(scope.target0) //不改变相机距离
    scope.object.position.copy(scope.position0)
    scope.object.zoom = scope.zoom0

    scope.object.updateProjectionMatrix()
    scope.dispatchEvent(changeEvent)

    scope.update()

    state = STATE.NONE
  }

  // this method is exposed, but perhaps it would be better if we can make it private...
  this.update = (function () {
    var offset = new THREE.Vector3()

    // so camera.up is the orbit axis
    var quat = new THREE.Quaternion().setFromUnitVectors(object.up, new THREE.Vector3(0, 1, 0))
    var quatInverse = quat.clone().inverse()

    var lastPosition = new THREE.Vector3()
    var lastQuaternion = new THREE.Quaternion()

    return function update() {
      var position = scope.object.position

      offset.copy(position).sub(scope.target)

      // rotate offset to "y-axis-is-up" space
      offset.applyQuaternion(quat)

      // angle from z-axis around y-axis
      spherical.setFromVector3(offset)

      if (scope.autoRotate && state === STATE.NONE) {
        rotateLeft(getAutoRotationAngle())
      }

      if (scope.enableDamping) {
        spherical.theta += sphericalDelta.theta * scope.dampingFactor
        spherical.phi += sphericalDelta.phi * scope.dampingFactor
      } else {
        spherical.theta += sphericalDelta.theta
        spherical.phi += sphericalDelta.phi
      }

      // restrict theta to be between desired limits
      spherical.theta = Math.max(scope.minAzimuthAngle, Math.min(scope.maxAzimuthAngle, spherical.theta))

      // restrict phi to be between desired limits
      spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi))

      spherical.makeSafe()

      spherical.radius *= scale
      // restrict radius to be between desired limits
      spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius))

      // move target to panned location

      if (scope.enableDamping === true) {
        scope.target.addScaledVector(panOffset, scope.dampingFactor)
      } else {
        scope.target.add(panOffset)
      }

      if (scope.minPan && scope.maxPan) scope.target.clamp(scope.minPan, scope.maxPan)

      offset.setFromSpherical(spherical)

      // rotate offset back to "camera-up-vector-is-up" space
      offset.applyQuaternion(quatInverse)

      position.copy(scope.target).add(offset)

      scope.object.lookAt(scope.target)

      if (scope.enableDamping === true) {
        sphericalDelta.theta *= 1 - scope.dampingFactor
        sphericalDelta.phi *= 1 - scope.dampingFactor

        panOffset.multiplyScalar(1 - scope.dampingFactor)
      } else {
        sphericalDelta.set(0, 0, 0)

        panOffset.set(0, 0, 0)
      }

      scale = 1

      // update condition is:
      // min(camera displacement, camera rotation in radians)^2 > EPS
      // using small-angle approximation cos(x/2) = 1 - x^2 / 8

      if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
        scope.dispatchEvent(changeEvent)

        lastPosition.copy(scope.object.position)
        lastQuaternion.copy(scope.object.quaternion)
        zoomChanged = false

        return true
      }

      return false
    }
  })()

  this.dispose = function () {
    scope.domElement.removeEventListener('contextmenu', onContextMenu, false)
    scope.domElement.removeEventListener('mousedown', onMouseDown, false)
    scope.domElement.removeEventListener('wheel', onMouseWheel, false)

    scope.domElement.removeEventListener('touchstart', onTouchStart, false)
    scope.domElement.removeEventListener('touchend', onTouchEnd, false)
    scope.domElement.removeEventListener('touchmove', onTouchMove, false)

    document.removeEventListener('mousemove', onMouseMove, false)
    document.removeEventListener('mouseup', onMouseUp, false)

    window.removeEventListener('keydown', onKeyDown, false)

    //scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
  }

  //
  // internals
  //

  var scope = this

  var changeEvent = { type: 'change' }
  var startEvent = { type: 'start' }
  var endEvent = { type: 'end' }

  var STATE = {
    NONE: -1,
    ROTATE: 0,
    DOLLY: 1,
    PAN: 2,
    TOUCH_ROTATE: 3,
    TOUCH_PAN: 4,
    TOUCH_DOLLY_PAN: 5,
    TOUCH_DOLLY_ROTATE: 6
  }

  var state = STATE.NONE

  var EPS = 0.000001

  // current position in spherical coordinates
  var spherical = new THREE.Spherical()
  var sphericalDelta = new THREE.Spherical()

  var scale = 1
  var panOffset = new THREE.Vector3()
  var zoomChanged = false

  var rotateStart = new THREE.Vector2()
  var rotateEnd = new THREE.Vector2()
  var rotateDelta = new THREE.Vector2()

  var panStart = new THREE.Vector2()
  var panEnd = new THREE.Vector2()
  var panDelta = new THREE.Vector2()

  var dollyStart = new THREE.Vector2()
  var dollyEnd = new THREE.Vector2()
  var dollyDelta = new THREE.Vector2()

  function getAutoRotationAngle() {
    return ((2 * Math.PI) / 60 / 60) * scope.autoRotateSpeed
  }

  function getZoomScale() {
    return Math.pow(0.95, scope.zoomSpeed)
  }

  function rotateLeft(angle) {
    sphericalDelta.theta -= angle
  }
  this.rotateLeft = rotateLeft
  function rotateUp(angle) {
    sphericalDelta.phi -= angle
  }
  this.rotateUp = rotateUp
  var panLeft = (function () {
    var v = new THREE.Vector3()

    return function panLeft(distance, objectMatrix) {
      v.setFromMatrixColumn(objectMatrix, 0) // get X column of objectMatrix
      v.multiplyScalar(-distance)
      panOffset.add(v)
    }
  })()

  var panUp = (function () {
    var v = new THREE.Vector3()

    return function panUp(distance, objectMatrix) {
      if (scope.screenSpacePanning === true) {
        v.setFromMatrixColumn(objectMatrix, 1)
      } else {
        v.setFromMatrixColumn(objectMatrix, 0)
        v.crossVectors(scope.object.up, v)
      }

      v.multiplyScalar(distance)

      panOffset.add(v)
    }
  })()

  // deltaX and deltaY are in pixels; right and down are positive
  var pan = (function () {
    var offset = new THREE.Vector3()

    return function pan(deltaX, deltaY) {
      var element = scope.domElement === document ? scope.domElement.body : scope.domElement

      if (scope.object.isPerspectiveCamera) {
        // perspective
        var position = scope.object.position
        offset.copy(position).sub(scope.target)
        var targetDistance = offset.length()

        // half of the fov is center to top of screen
        targetDistance *= Math.tan(((scope.object.fov / 2) * Math.PI) / 180.0)

        // we use only clientHeight here so aspect ratio does not distort speed
        panLeft((2 * deltaX * targetDistance) / element.clientHeight, scope.object.matrix)
        panUp((2 * deltaY * targetDistance) / element.clientHeight, scope.object.matrix)
      } else if (scope.object.isOrthographicCamera) {
        // orthographic
        panLeft((deltaX * (scope.object.right - scope.object.left)) / scope.object.zoom / element.clientWidth, scope.object.matrix)
        panUp((deltaY * (scope.object.top - scope.object.bottom)) / scope.object.zoom / element.clientHeight, scope.object.matrix)
      } else {
        // camera neither orthographic nor perspective
        console.warn('WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.')
        scope.enablePan = false
      }
    }
  })()
  this.pan = pan
  function dollyIn(dollyScale) {
    if (scope.object.isPerspectiveCamera) {
      scale /= dollyScale
    } else if (scope.object.isOrthographicCamera) {
      scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale))
      scope.object.updateProjectionMatrix()
      zoomChanged = true
    } else {
      console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.')
      scope.enableZoom = false
    }
  }

  function dollyOut(dollyScale) {
    if (scope.object.isPerspectiveCamera) {
      scale *= dollyScale
    } else if (scope.object.isOrthographicCamera) {
      scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale))
      scope.object.updateProjectionMatrix()
      zoomChanged = true
    } else {
      console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.')
      scope.enableZoom = false
    }
  }

  //
  // event callbacks - update the object state
  //

  function handleMouseDownRotate(event) {
    rotateStart.set(event.clientX, event.clientY)
  }

  function handleMouseDownDolly(event) {
    dollyStart.set(event.clientX, event.clientY)
  }

  function handleMouseDownPan(event) {
    panStart.set(event.clientX, event.clientY)
  }

  function handleMouseMoveRotate(event) {
    rotateEnd.set(event.clientX, event.clientY)

    rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed)

    var element = scope.domElement === document ? scope.domElement.body : scope.domElement

    rotateLeft((2 * Math.PI * rotateDelta.x) / element.clientHeight) // yes, height

    rotateUp((2 * Math.PI * rotateDelta.y) / element.clientHeight)

    rotateStart.copy(rotateEnd)

    scope.update()
  }

  function handleMouseMoveDolly(event) {
    dollyEnd.set(event.clientX, event.clientY)

    dollyDelta.subVectors(dollyEnd, dollyStart)

    if (dollyDelta.y > 0) {
      dollyIn(getZoomScale())
    } else if (dollyDelta.y < 0) {
      dollyOut(getZoomScale())
    }

    dollyStart.copy(dollyEnd)

    scope.update()
  }

  function handleMouseMovePan(event) {
    panEnd.set(event.clientX, event.clientY)

    panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed)

    pan(panDelta.x, panDelta.y)

    panStart.copy(panEnd)

    scope.update()
  }

  function handleMouseUp(/*event*/) {
    // no-op
  }

  function handleMouseWheel(event) {
    if (event.deltaY < 0) {
      dollyOut(getZoomScale())
    } else if (event.deltaY > 0) {
      dollyIn(getZoomScale())
    }

    scope.update()
  }

  function handleKeyDown(event) {
    var needsUpdate = false

    switch (event.keyCode) {
      case scope.keys.UP:
        pan(0, scope.keyPanSpeed)
        needsUpdate = true
        break

      case scope.keys.BOTTOM:
        pan(0, -scope.keyPanSpeed)
        needsUpdate = true
        break

      case scope.keys.LEFT:
        pan(scope.keyPanSpeed, 0)
        needsUpdate = true
        break

      case scope.keys.RIGHT:
        pan(-scope.keyPanSpeed, 0)
        needsUpdate = true
        break
    }

    if (needsUpdate) {
      // prevent the browser from scrolling on cursor keys
      event.preventDefault()

      scope.update()
    }
  }

  function handleTouchStartRotate(event) {
    if (event.touches.length == 1) {
      rotateStart.set(event.touches[0].pageX, event.touches[0].pageY)
    } else {
      var x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX)
      var y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY)

      rotateStart.set(x, y)
    }
  }

  function handleTouchStartPan(event) {
    if (event.touches.length == 1) {
      panStart.set(event.touches[0].pageX, event.touches[0].pageY)
    } else {
      var x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX)
      var y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY)

      panStart.set(x, y)
    }
  }

  function handleTouchStartDolly(event) {
    var dx = event.touches[0].pageX - event.touches[1].pageX
    var dy = event.touches[0].pageY - event.touches[1].pageY

    var distance = Math.sqrt(dx * dx + dy * dy)

    dollyStart.set(0, distance)
  }

  function handleTouchStartDollyPan(event) {
    if (scope.enableZoom) handleTouchStartDolly(event)

    if (scope.enablePan) handleTouchStartPan(event)
  }

  function handleTouchStartDollyRotate(event) {
    if (scope.enableZoom) handleTouchStartDolly(event)

    if (scope.enableRotate) handleTouchStartRotate(event)
  }

  function handleTouchMoveRotate(event) {
    if (event.touches.length == 1) {
      rotateEnd.set(event.touches[0].pageX, event.touches[0].pageY)
    } else {
      var x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX)
      var y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY)

      rotateEnd.set(x, y)
    }

    rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed)

    var element = scope.domElement === document ? scope.domElement.body : scope.domElement

    scope instanceof THREE.OrbitControls && rotateLeft((2 * Math.PI * rotateDelta.x) / element.clientHeight) // yes, height

    rotateUp((2 * Math.PI * rotateDelta.y) / element.clientHeight)

    rotateStart.copy(rotateEnd)
  }

  function handleTouchMovePan(event) {
    if (event.touches.length == 1) {
      panEnd.set(event.touches[0].pageX, event.touches[0].pageY)
    } else {
      var x = 0.5 * (event.touches[0].pageX + event.touches[1].pageX)
      var y = 0.5 * (event.touches[0].pageY + event.touches[1].pageY)

      panEnd.set(x, y)
    }

    panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed)

    pan(panDelta.x, panDelta.y)

    panStart.copy(panEnd)
  }

  function handleTouchMoveDolly(event) {
    var dx = event.touches[0].pageX - event.touches[1].pageX
    var dy = event.touches[0].pageY - event.touches[1].pageY

    var distance = Math.sqrt(dx * dx + dy * dy)

    dollyEnd.set(0, distance)

    dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed))

    dollyIn(dollyDelta.y)

    dollyStart.copy(dollyEnd)
  }

  function handleTouchMoveDollyPan(event) {
    if (scope.enableZoom) handleTouchMoveDolly(event)

    if (scope.enablePan) handleTouchMovePan(event)
  }

  function handleTouchMoveDollyRotate(event) {
    if (scope.enableZoom) handleTouchMoveDolly(event)

    if (scope.enableRotate) handleTouchMoveRotate(event)
  }

  function handleTouchEnd(/*event*/) {
    // no-op
  }

  //
  // event handlers - FSM: listen for events and reset state
  //

  function onMouseDown(event) {
    if (scope.enabled === false) return

    // Prevent the browser from scrolling.

    event.preventDefault()

    // Manually set the focus since calling preventDefault above
    // prevents the browser from setting it automatically.

    scope.domElement.focus ? scope.domElement.focus() : window.focus()

    switch (event.button) {
      case 0:
        switch (scope.mouseButtons.LEFT) {
          case THREE.MOUSE.ROTATE:
            if (event.ctrlKey || event.metaKey || event.shiftKey) {
              if (scope.enablePan === false) return

              handleMouseDownPan(event)

              state = STATE.PAN
            } else {
              if (scope.enableRotate === false) return

              handleMouseDownRotate(event)

              state = STATE.ROTATE
            }

            break

          case THREE.MOUSE.PAN:
            if (event.ctrlKey || event.metaKey || event.shiftKey) {
              if (scope.enableRotate === false) return

              handleMouseDownRotate(event)

              state = STATE.ROTATE
            } else {
              if (scope.enablePan === false) return

              handleMouseDownPan(event)

              state = STATE.PAN
            }

            break

          default:
            state = STATE.NONE
        }

        break

      case 1:
        switch (scope.mouseButtons.MIDDLE) {
          case THREE.MOUSE.DOLLY:
            if (scope.enableZoom === false) return

            handleMouseDownDolly(event)

            state = STATE.DOLLY

            break

          default:
            state = STATE.NONE
        }

        break

      case 2:
        switch (scope.mouseButtons.RIGHT) {
          case THREE.MOUSE.ROTATE:
            if (scope.enableRotate === false) return

            handleMouseDownRotate(event)

            state = STATE.ROTATE

            break

          case THREE.MOUSE.PAN:
            if (scope.enablePan === false) return

            handleMouseDownPan(event)

            state = STATE.PAN

            break

          default:
            state = STATE.NONE
        }

        break
    }

    if (state !== STATE.NONE) {
      document.addEventListener('mousemove', onMouseMove, false)
      document.addEventListener('mouseup', onMouseUp, false)

      scope.dispatchEvent(startEvent)
    }
  }

  function onMouseMove(event) {
    if (scope.enabled === false) return

    event.preventDefault()

    switch (state) {
      case STATE.ROTATE:
        if (scope.enableRotate === false) return

        handleMouseMoveRotate(event)

        break

      case STATE.DOLLY:
        if (scope.enableZoom === false) return

        handleMouseMoveDolly(event)

        break

      case STATE.PAN:
        if (scope.enablePan === false) return

        handleMouseMovePan(event)

        break
    }
  }

  function onMouseUp(event) {
    if (scope.enabled === false) return

    handleMouseUp(event)

    document.removeEventListener('mousemove', onMouseMove, false)
    document.removeEventListener('mouseup', onMouseUp, false)

    scope.dispatchEvent(endEvent)

    state = STATE.NONE
  }

  function onMouseWheel(event) {
    if (scope.enabled === false || scope.enableZoom === false || (state !== STATE.NONE && state !== STATE.ROTATE)) return

    event.preventDefault()
    event.stopPropagation()

    scope.dispatchEvent(startEvent)

    handleMouseWheel(event)

    scope.dispatchEvent(endEvent)
  }

  function onKeyDown(event) {
    if (scope.enabled === false || scope.enableKeys === false || scope.enablePan === false) return

    handleKeyDown(event)
  }

  function onTouchStart(event) {
    if (scope.enabled === false) return

    //event.preventDefault();

    switch (event.touches.length) {
      case 1:
        switch (scope.touches.ONE) {
          case THREE.TOUCH.ROTATE:
            if (scope.enableRotate === false) return

            handleTouchStartRotate(event)

            state = STATE.TOUCH_ROTATE

            break

          case THREE.TOUCH.PAN:
            if (scope.enablePan === false) return

            handleTouchStartPan(event)

            state = STATE.TOUCH_PAN

            break

          default:
            state = STATE.NONE
        }

        break

      case 2:
        switch (scope.touches.TWO) {
          case THREE.TOUCH.DOLLY_PAN:
            if (scope.enableZoom === false && scope.enablePan === false) return

            handleTouchStartDollyPan(event)

            state = STATE.TOUCH_DOLLY_PAN

            break

          case THREE.TOUCH.DOLLY_ROTATE:
            if (scope.enableZoom === false && scope.enableRotate === false) return

            handleTouchStartDollyRotate(event)

            state = STATE.TOUCH_DOLLY_ROTATE

            break

          default:
            state = STATE.NONE
        }

        break

      default:
        state = STATE.NONE
    }

    if (state !== STATE.NONE) {
      scope.dispatchEvent(startEvent)
    }
  }

  function onTouchMove(event) {
    if (scope.enabled === false) return

    event.preventDefault()
    event.stopPropagation()

    switch (state) {
      case STATE.TOUCH_ROTATE:
        if (scope.enableRotate === false) return

        handleTouchMoveRotate(event)

        scope.update()

        break

      case STATE.TOUCH_PAN:
        if (scope.enablePan === false) return

        handleTouchMovePan(event)

        scope.update()

        break

      case STATE.TOUCH_DOLLY_PAN:
        if (scope.enableZoom === false && scope.enablePan === false) return

        handleTouchMoveDollyPan(event)

        scope.update()

        break

      case STATE.TOUCH_DOLLY_ROTATE:
        if (scope.enableZoom === false && scope.enableRotate === false) return

        handleTouchMoveDollyRotate(event)

        scope.update()

        break

      default:
        state = STATE.NONE
    }
  }

  function onTouchEnd(event) {
    if (scope.enabled === false) return

    handleTouchEnd(event)

    scope.dispatchEvent(endEvent)

    state = STATE.NONE
  }

  function onContextMenu(event) {
    if (scope.enabled === false) return

    event.preventDefault()
  }

  //

  scope.domElement.addEventListener('contextmenu', onContextMenu, false)

  scope.domElement.addEventListener('mousedown', onMouseDown, false)
  scope.domElement.addEventListener('wheel', onMouseWheel, false)

  scope.domElement.addEventListener('touchstart', onTouchStart, false)
  scope.domElement.addEventListener('touchend', onTouchEnd, false)
  scope.domElement.addEventListener('touchmove', onTouchMove, false)
  window.addEventListener('keydown', onKeyDown, false)
  // force an update at start
  this.update()
}

THREE.OrbitControls.prototype = Object.create(THREE.EventDispatcher.prototype)
THREE.OrbitControls.prototype.constructor = THREE.OrbitControls

var _gsScope = 'undefined' != typeof module && module.exports && 'undefined' != typeof global ? global : this || window
;(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push(function () {
  'use strict'
  _gsScope._gsDefine(
    'TweenMax',
    ['core.Animation', 'core.SimpleTimeline', 'TweenLite'],
    function (a, b, c) {
      var d = function (a) {
          var b,
            c = [],
            d = a.length
          for (b = 0; b !== d; c.push(a[b++]));
          return c
        },
        e = function (a, b, c) {
          var d,
            e,
            f = a.cycle
          for (d in f) (e = f[d]), (a[d] = 'function' == typeof e ? e(c, b[c], b) : e[c % e.length])
          delete a.cycle
        },
        f = function (a) {
          if ('function' == typeof a) return a
          var b = 'object' == typeof a ? a : { each: a },
            c = b.ease,
            d = b.from || 0,
            e = b.base || 0,
            f = {},
            g = isNaN(d),
            h = b.axis,
            i = { center: 0.5, end: 1 }[d] || 0
          return function (a, j, k) {
            var l,
              m,
              n,
              o,
              p,
              q,
              r,
              s,
              t,
              u = (k || b).length,
              v = f[u]
            if (!v) {
              if (((t = 'auto' === b.grid ? 0 : (b.grid || [1 / 0])[0]), !t)) {
                for (r = -(1 / 0); r < (r = k[t++].getBoundingClientRect().left) && u > t; );
                t--
              }
              for (v = f[u] = [], l = g ? Math.min(t, u) * i - 0.5 : d % t, m = g ? (u * i) / t - 0.5 : (d / t) | 0, r = 0, s = 1 / 0, q = 0; u > q; q++)
                (n = (q % t) - l), (o = m - ((q / t) | 0)), (v[q] = p = h ? Math.abs('y' === h ? o : n) : Math.sqrt(n * n + o * o)), p > r && (r = p), s > p && (s = p)
              ;(v.max = r - s),
                (v.min = s),
                (v.v = u = b.amount || b.each * (t > u ? u : h ? ('y' === h ? u / t : t) : Math.max(t, u / t)) || 0),
                (v.b = 0 > u ? e - u : e)
            }
            return (u = (v[a] - v.min) / v.max), v.b + (c ? c.getRatio(u) : u) * v.v
          }
        },
        g = function (a, b, d) {
          c.call(this, a, b, d),
            (this._cycle = 0),
            (this._yoyo = this.vars.yoyo === !0 || !!this.vars.yoyoEase),
            (this._repeat = this.vars.repeat || 0),
            (this._repeatDelay = this.vars.repeatDelay || 0),
            this._repeat && this._uncache(!0),
            (this.render = g.prototype.render)
        },
        h = 1e-8,
        i = c._internals,
        j = i.isSelector,
        k = i.isArray,
        l = (g.prototype = c.to({}, 0.1, {})),
        m = []
      ;(g.version = '2.1.2'),
        (l.constructor = g),
        (l.kill()._gc = !1),
        (g.killTweensOf = g.killDelayedCallsTo = c.killTweensOf),
        (g.getTweensOf = c.getTweensOf),
        (g.lagSmoothing = c.lagSmoothing),
        (g.ticker = c.ticker),
        (g.render = c.render),
        (g.distribute = f),
        (l.invalidate = function () {
          return (
            (this._yoyo = this.vars.yoyo === !0 || !!this.vars.yoyoEase),
            (this._repeat = this.vars.repeat || 0),
            (this._repeatDelay = this.vars.repeatDelay || 0),
            (this._yoyoEase = null),
            this._uncache(!0),
            c.prototype.invalidate.call(this)
          )
        }),
        (l.updateTo = function (a, b) {
          var d,
            e = this,
            f = e.ratio,
            g = e.vars.immediateRender || a.immediateRender
          b &&
            e._startTime < e._timeline._time &&
            ((e._startTime = e._timeline._time), e._uncache(!1), e._gc ? e._enabled(!0, !1) : e._timeline.insert(e, e._startTime - e._delay))
          for (d in a) e.vars[d] = a[d]
          if (e._initted || g)
            if (b) (e._initted = !1), g && e.render(0, !0, !0)
            else if ((e._gc && e._enabled(!0, !1), e._notifyPluginsOfEnabled && e._firstPT && c._onPluginEvent('_onDisable', e), e._time / e._duration > 0.998)) {
              var h = e._totalTime
              e.render(0, !0, !1), (e._initted = !1), e.render(h, !0, !1)
            } else if (((e._initted = !1), e._init(), e._time > 0 || g))
              for (var i, j = 1 / (1 - f), k = e._firstPT; k; ) (i = k.s + k.c), (k.c *= j), (k.s = i - k.c), (k = k._next)
          return e
        }),
        (l.render = function (a, b, d) {
          this._initted || (0 === this._duration && this.vars.repeat && this.invalidate())
          var e,
            f,
            g,
            j,
            k,
            l,
            m,
            n,
            o,
            p = this,
            q = p._dirty ? p.totalDuration() : p._totalDuration,
            r = p._time,
            s = p._totalTime,
            t = p._cycle,
            u = p._duration,
            v = p._rawPrevTime
          if (
            (a >= q - h && a >= 0
              ? ((p._totalTime = q),
                (p._cycle = p._repeat),
                p._yoyo && 0 !== (1 & p._cycle)
                  ? ((p._time = 0), (p.ratio = p._ease._calcEnd ? p._ease.getRatio(0) : 0))
                  : ((p._time = u), (p.ratio = p._ease._calcEnd ? p._ease.getRatio(1) : 1)),
                p._reversed || ((e = !0), (f = 'onComplete'), (d = d || p._timeline.autoRemoveChildren)),
                0 === u &&
                  (p._initted || !p.vars.lazy || d) &&
                  (p._startTime === p._timeline._duration && (a = 0),
                  (0 > v || (0 >= a && a >= -h) || (v === h && 'isPause' !== p.data)) && v !== a && ((d = !0), v > h && (f = 'onReverseComplete')),
                  (p._rawPrevTime = n = !b || a || v === a ? a : h)))
              : h > a
              ? ((p._totalTime = p._time = p._cycle = 0),
                (p.ratio = p._ease._calcEnd ? p._ease.getRatio(0) : 0),
                (0 !== s || (0 === u && v > 0)) && ((f = 'onReverseComplete'), (e = p._reversed)),
                a > -h
                  ? (a = 0)
                  : 0 > a && ((p._active = !1), 0 === u && (p._initted || !p.vars.lazy || d) && (v >= 0 && (d = !0), (p._rawPrevTime = n = !b || a || v === a ? a : h))),
                p._initted || (d = !0))
              : ((p._totalTime = p._time = a),
                0 !== p._repeat &&
                  ((j = u + p._repeatDelay),
                  (p._cycle = (p._totalTime / j) >> 0),
                  0 !== p._cycle && p._cycle === p._totalTime / j && a >= s && p._cycle--,
                  (p._time = p._totalTime - p._cycle * j),
                  p._yoyo &&
                    0 !== (1 & p._cycle) &&
                    ((p._time = u - p._time),
                    (o = p._yoyoEase || p.vars.yoyoEase),
                    o &&
                      (p._yoyoEase ||
                        (o !== !0 || p._initted
                          ? (p._yoyoEase = o = o === !0 ? p._ease : o instanceof Ease ? o : Ease.map[o])
                          : ((o = p.vars.ease),
                            (p._yoyoEase = o =
                              o ? (o instanceof Ease ? o : 'function' == typeof o ? new Ease(o, p.vars.easeParams) : Ease.map[o] || c.defaultEase) : c.defaultEase))),
                      (p.ratio = o ? 1 - o.getRatio((u - p._time) / u) : 0))),
                  p._time > u ? (p._time = u) : p._time < 0 && (p._time = 0)),
                p._easeType && !o
                  ? ((k = p._time / u),
                    (l = p._easeType),
                    (m = p._easePower),
                    (1 === l || (3 === l && k >= 0.5)) && (k = 1 - k),
                    3 === l && (k *= 2),
                    1 === m ? (k *= k) : 2 === m ? (k *= k * k) : 3 === m ? (k *= k * k * k) : 4 === m && (k *= k * k * k * k),
                    (p.ratio = 1 === l ? 1 - k : 2 === l ? k : p._time / u < 0.5 ? k / 2 : 1 - k / 2))
                  : o || (p.ratio = p._ease.getRatio(p._time / u))),
            r === p._time && !d && t === p._cycle)
          )
            return void (s !== p._totalTime && p._onUpdate && (b || p._callback('onUpdate')))
          if (!p._initted) {
            if ((p._init(), !p._initted || p._gc)) return
            if (!d && p._firstPT && ((p.vars.lazy !== !1 && p._duration) || (p.vars.lazy && !p._duration)))
              return (p._time = r), (p._totalTime = s), (p._rawPrevTime = v), (p._cycle = t), i.lazyTweens.push(p), void (p._lazy = [a, b])
            !p._time || e || o ? e && this._ease._calcEnd && !o && (p.ratio = p._ease.getRatio(0 === p._time ? 0 : 1)) : (p.ratio = p._ease.getRatio(p._time / u))
          }
          for (
            p._lazy !== !1 && (p._lazy = !1),
              p._active || (!p._paused && p._time !== r && a >= 0 && (p._active = !0)),
              0 === s &&
                (2 === p._initted && a > 0 && p._init(),
                p._startAt && (a >= 0 ? p._startAt.render(a, !0, d) : f || (f = '_dummyGS')),
                p.vars.onStart && (0 !== p._totalTime || 0 === u) && (b || p._callback('onStart'))),
              g = p._firstPT;
            g;

          )
            g.f ? g.t[g.p](g.c * p.ratio + g.s) : (g.t[g.p] = g.c * p.ratio + g.s), (g = g._next)
          p._onUpdate && (0 > a && p._startAt && p._startTime && p._startAt.render(a, !0, d), b || ((p._totalTime !== s || f) && p._callback('onUpdate'))),
            p._cycle !== t && (b || p._gc || (p.vars.onRepeat && p._callback('onRepeat'))),
            f &&
              (!p._gc || d) &&
              (0 > a && p._startAt && !p._onUpdate && p._startTime && p._startAt.render(a, !0, d),
              e && (p._timeline.autoRemoveChildren && p._enabled(!1, !1), (p._active = !1)),
              !b && p.vars[f] && p._callback(f),
              0 === u && p._rawPrevTime === h && n !== h && (p._rawPrevTime = 0))
        }),
        (g.to = function (a, b, c) {
          return new g(a, b, c)
        }),
        (g.from = function (a, b, c) {
          return (c.runBackwards = !0), (c.immediateRender = 0 != c.immediateRender), new g(a, b, c)
        }),
        (g.fromTo = function (a, b, c, d) {
          return (d.startAt = c), (d.immediateRender = 0 != d.immediateRender && 0 != c.immediateRender), new g(a, b, d)
        }),
        (g.staggerTo = g.allTo =
          function (a, b, h, i, l, n, o) {
            var p,
              q,
              r,
              s,
              t = [],
              u = f(h.stagger || i),
              v = h.cycle,
              w = (h.startAt || m).cycle
            for (k(a) || ('string' == typeof a && (a = c.selector(a) || a), j(a) && (a = d(a))), a = a || [], p = a.length - 1, r = 0; p >= r; r++) {
              q = {}
              for (s in h) q[s] = h[s]
              if ((v && (e(q, a, r), null != q.duration && ((b = q.duration), delete q.duration)), w)) {
                w = q.startAt = {}
                for (s in h.startAt) w[s] = h.startAt[s]
                e(q.startAt, a, r)
              }
              ;(q.delay = u(r, a[r], a) + (q.delay || 0)),
                r === p &&
                  l &&
                  (q.onComplete = function () {
                    h.onComplete && h.onComplete.apply(h.onCompleteScope || this, arguments), l.apply(o || h.callbackScope || this, n || m)
                  }),
                (t[r] = new g(a[r], b, q))
            }
            return t
          }),
        (g.staggerFrom = g.allFrom =
          function (a, b, c, d, e, f, h) {
            return (c.runBackwards = !0), (c.immediateRender = 0 != c.immediateRender), g.staggerTo(a, b, c, d, e, f, h)
          }),
        (g.staggerFromTo = g.allFromTo =
          function (a, b, c, d, e, f, h, i) {
            return (d.startAt = c), (d.immediateRender = 0 != d.immediateRender && 0 != c.immediateRender), g.staggerTo(a, b, d, e, f, h, i)
          }),
        (g.delayedCall = function (a, b, c, d, e) {
          return new g(b, 0, {
            delay: a,
            onComplete: b,
            onCompleteParams: c,
            callbackScope: d,
            onReverseComplete: b,
            onReverseCompleteParams: c,
            immediateRender: !1,
            useFrames: e,
            overwrite: 0
          })
        }),
        (g.set = function (a, b) {
          return new g(a, 0, b)
        }),
        (g.isTweening = function (a) {
          return c.getTweensOf(a, !0).length > 0
        })
      var n = function (a, b) {
          for (var d = [], e = 0, f = a._first; f; ) f instanceof c ? (d[e++] = f) : (b && (d[e++] = f), (d = d.concat(n(f, b))), (e = d.length)), (f = f._next)
          return d
        },
        o = (g.getAllTweens = function (b) {
          return n(a._rootTimeline, b).concat(n(a._rootFramesTimeline, b))
        })
      ;(g.killAll = function (a, c, d, e) {
        null == c && (c = !0), null == d && (d = !0)
        var f,
          g,
          h,
          i = o(0 != e),
          j = i.length,
          k = c && d && e
        for (h = 0; j > h; h++)
          (g = i[h]),
            (k || g instanceof b || ((f = g.target === g.vars.onComplete) && d) || (c && !f)) &&
              (a ? g.totalTime(g._reversed ? 0 : g.totalDuration()) : g._enabled(!1, !1))
      }),
        (g.killChildTweensOf = function (a, b) {
          if (null != a) {
            var e,
              f,
              h,
              l,
              m,
              n = i.tweenLookup
            if (('string' == typeof a && (a = c.selector(a) || a), j(a) && (a = d(a)), k(a))) for (l = a.length; --l > -1; ) g.killChildTweensOf(a[l], b)
            else {
              e = []
              for (h in n) for (f = n[h].target.parentNode; f; ) f === a && (e = e.concat(n[h].tweens)), (f = f.parentNode)
              for (m = e.length, l = 0; m > l; l++) b && e[l].totalTime(e[l].totalDuration()), e[l]._enabled(!1, !1)
            }
          }
        })
      var p = function (a, c, d, e) {
        ;(c = c !== !1), (d = d !== !1), (e = e !== !1)
        for (var f, g, h = o(e), i = c && d && e, j = h.length; --j > -1; )
          (g = h[j]), (i || g instanceof b || ((f = g.target === g.vars.onComplete) && d) || (c && !f)) && g.paused(a)
      }
      return (
        (g.pauseAll = function (a, b, c) {
          p(!0, a, b, c)
        }),
        (g.resumeAll = function (a, b, c) {
          p(!1, a, b, c)
        }),
        (g.globalTimeScale = function (b) {
          var d = a._rootTimeline,
            e = c.ticker.time
          return arguments.length
            ? ((b = b || h),
              (d._startTime = e - ((e - d._startTime) * d._timeScale) / b),
              (d = a._rootFramesTimeline),
              (e = c.ticker.frame),
              (d._startTime = e - ((e - d._startTime) * d._timeScale) / b),
              (d._timeScale = a._rootTimeline._timeScale = b),
              b)
            : d._timeScale
        }),
        (l.progress = function (a, b) {
          return arguments.length
            ? this.totalTime(this.duration() * (this._yoyo && 0 !== (1 & this._cycle) ? 1 - a : a) + this._cycle * (this._duration + this._repeatDelay), b)
            : this._time / this.duration()
        }),
        (l.totalProgress = function (a, b) {
          return arguments.length ? this.totalTime(this.totalDuration() * a, b) : this._totalTime / this.totalDuration()
        }),
        (l.time = function (a, b) {
          if (!arguments.length) return this._time
          this._dirty && this.totalDuration()
          var c = this._duration,
            d = this._cycle,
            e = d * (c + this._repeatDelay)
          return a > c && (a = c), this.totalTime(this._yoyo && 1 & d ? c - a + e : this._repeat ? a + e : a, b)
        }),
        (l.duration = function (b) {
          return arguments.length ? a.prototype.duration.call(this, b) : this._duration
        }),
        (l.totalDuration = function (a) {
          return arguments.length
            ? -1 === this._repeat
              ? this
              : this.duration((a - this._repeat * this._repeatDelay) / (this._repeat + 1))
            : (this._dirty &&
                ((this._totalDuration = -1 === this._repeat ? 999999999999 : this._duration * (this._repeat + 1) + this._repeatDelay * this._repeat), (this._dirty = !1)),
              this._totalDuration)
        }),
        (l.repeat = function (a) {
          return arguments.length ? ((this._repeat = a), this._uncache(!0)) : this._repeat
        }),
        (l.repeatDelay = function (a) {
          return arguments.length ? ((this._repeatDelay = a), this._uncache(!0)) : this._repeatDelay
        }),
        (l.yoyo = function (a) {
          return arguments.length ? ((this._yoyo = a), this) : this._yoyo
        }),
        g
      )
    },
    !0
  ),
    _gsScope._gsDefine(
      'TimelineLite',
      ['core.Animation', 'core.SimpleTimeline', 'TweenLite'],
      function (a, b, c) {
        var d = function (a) {
            b.call(this, a)
            var c,
              d,
              e = this,
              f = e.vars
            ;(e._labels = {}),
              (e.autoRemoveChildren = !!f.autoRemoveChildren),
              (e.smoothChildTiming = !!f.smoothChildTiming),
              (e._sortChildren = !0),
              (e._onUpdate = f.onUpdate)
            for (d in f) (c = f[d]), i(c) && -1 !== c.join('').indexOf('{self}') && (f[d] = e._swapSelfInParams(c))
            i(f.tweens) && e.add(f.tweens, 0, f.align, f.stagger)
          },
          e = 1e-8,
          f = c._internals,
          g = (d._internals = {}),
          h = f.isSelector,
          i = f.isArray,
          j = f.lazyTweens,
          k = f.lazyRender,
          l = _gsScope._gsDefine.globals,
          m = function (a) {
            var b,
              c = {}
            for (b in a) c[b] = a[b]
            return c
          },
          n = function (a, b, c) {
            var d,
              e,
              f = a.cycle
            for (d in f) (e = f[d]), (a[d] = 'function' == typeof e ? e(c, b[c], b) : e[c % e.length])
            delete a.cycle
          },
          o = (g.pauseCallback = function () {}),
          p = function (a) {
            var b,
              c = [],
              d = a.length
            for (b = 0; b !== d; c.push(a[b++]));
            return c
          },
          q = function (a, b, c, d) {
            var e = 'immediateRender'
            return e in b || (b[e] = !((c && c[e] === !1) || d)), b
          },
          r = function (a) {
            if ('function' == typeof a) return a
            var b = 'object' == typeof a ? a : { each: a },
              c = b.ease,
              d = b.from || 0,
              e = b.base || 0,
              f = {},
              g = isNaN(d),
              h = b.axis,
              i = { center: 0.5, end: 1 }[d] || 0
            return function (a, j, k) {
              var l,
                m,
                n,
                o,
                p,
                q,
                r,
                s,
                t,
                u = (k || b).length,
                v = f[u]
              if (!v) {
                if (((t = 'auto' === b.grid ? 0 : (b.grid || [1 / 0])[0]), !t)) {
                  for (r = -(1 / 0); r < (r = k[t++].getBoundingClientRect().left) && u > t; );
                  t--
                }
                for (v = f[u] = [], l = g ? Math.min(t, u) * i - 0.5 : d % t, m = g ? (u * i) / t - 0.5 : (d / t) | 0, r = 0, s = 1 / 0, q = 0; u > q; q++)
                  (n = (q % t) - l), (o = m - ((q / t) | 0)), (v[q] = p = h ? Math.abs('y' === h ? o : n) : Math.sqrt(n * n + o * o)), p > r && (r = p), s > p && (s = p)
                ;(v.max = r - s),
                  (v.min = s),
                  (v.v = u = b.amount || b.each * (t > u ? u : h ? ('y' === h ? u / t : t) : Math.max(t, u / t)) || 0),
                  (v.b = 0 > u ? e - u : e)
              }
              return (u = (v[a] - v.min) / v.max), v.b + (c ? c.getRatio(u) : u) * v.v
            }
          },
          s = (d.prototype = new b())
        return (
          (d.version = '2.1.2'),
          (d.distribute = r),
          (s.constructor = d),
          (s.kill()._gc = s._forcingPlayhead = s._hasPause = !1),
          (s.to = function (a, b, d, e) {
            var f = (d.repeat && l.TweenMax) || c
            return b ? this.add(new f(a, b, d), e) : this.set(a, d, e)
          }),
          (s.from = function (a, b, d, e) {
            return this.add(((d.repeat && l.TweenMax) || c).from(a, b, q(this, d)), e)
          }),
          (s.fromTo = function (a, b, d, e, f) {
            var g = (e.repeat && l.TweenMax) || c
            return (e = q(this, e, d)), b ? this.add(g.fromTo(a, b, d, e), f) : this.set(a, e, f)
          }),
          (s.staggerTo = function (a, b, e, f, g, i, j, k) {
            var l,
              o,
              q = new d({ onComplete: i, onCompleteParams: j, callbackScope: k, smoothChildTiming: this.smoothChildTiming }),
              s = r(e.stagger || f),
              t = e.startAt,
              u = e.cycle
            for ('string' == typeof a && (a = c.selector(a) || a), a = a || [], h(a) && (a = p(a)), o = 0; o < a.length; o++)
              (l = m(e)),
                t && ((l.startAt = m(t)), t.cycle && n(l.startAt, a, o)),
                u && (n(l, a, o), null != l.duration && ((b = l.duration), delete l.duration)),
                q.to(a[o], b, l, s(o, a[o], a))
            return this.add(q, g)
          }),
          (s.staggerFrom = function (a, b, c, d, e, f, g, h) {
            return (c.runBackwards = !0), this.staggerTo(a, b, q(this, c), d, e, f, g, h)
          }),
          (s.staggerFromTo = function (a, b, c, d, e, f, g, h, i) {
            return (d.startAt = c), this.staggerTo(a, b, q(this, d, c), e, f, g, h, i)
          }),
          (s.call = function (a, b, d, e) {
            return this.add(c.delayedCall(0, a, b, d), e)
          }),
          (s.set = function (a, b, d) {
            return this.add(new c(a, 0, q(this, b, null, !0)), d)
          }),
          (d.exportRoot = function (a, b) {
            ;(a = a || {}), null == a.smoothChildTiming && (a.smoothChildTiming = !0)
            var e,
              f,
              g,
              h,
              i = new d(a),
              j = i._timeline
            for (null == b && (b = !0), j._remove(i, !0), i._startTime = 0, i._rawPrevTime = i._time = i._totalTime = j._time, g = j._first; g; )
              (h = g._next), (b && g instanceof c && g.target === g.vars.onComplete) || ((f = g._startTime - g._delay), 0 > f && (e = 1), i.add(g, f)), (g = h)
            return j.add(i, 0), e && i.totalDuration(), i
          }),
          (s.add = function (e, f, g, h) {
            var j,
              k,
              l,
              m,
              n,
              o,
              p = this
            if (('number' != typeof f && (f = p._parseTimeOrLabel(f, 0, !0, e)), !(e instanceof a))) {
              if (e instanceof Array || (e && e.push && i(e))) {
                for (g = g || 'normal', h = h || 0, j = f, k = e.length, l = 0; k > l; l++)
                  i((m = e[l])) && (m = new d({ tweens: m })),
                    p.add(m, j),
                    'string' != typeof m &&
                      'function' != typeof m &&
                      ('sequence' === g ? (j = m._startTime + m.totalDuration() / m._timeScale) : 'start' === g && (m._startTime -= m.delay())),
                    (j += h)
                return p._uncache(!0)
              }
              if ('string' == typeof e) return p.addLabel(e, f)
              if ('function' != typeof e) throw 'Cannot add ' + e + ' into the timeline; it is not a tween, timeline, function, or string.'
              e = c.delayedCall(0, e)
            }
            if (
              (b.prototype.add.call(p, e, f),
              (e._time || (!e._duration && e._initted)) &&
                ((j = (p.rawTime() - e._startTime) * e._timeScale),
                (!e._duration || Math.abs(Math.max(0, Math.min(e.totalDuration(), j))) - e._totalTime > 1e-5) && e.render(j, !1, !1)),
              (p._gc || p._time === p._duration) && !p._paused && p._duration < p.duration())
            )
              for (n = p, o = n.rawTime() > e._startTime; n._timeline; )
                o && n._timeline.smoothChildTiming ? n.totalTime(n._totalTime, !0) : n._gc && n._enabled(!0, !1), (n = n._timeline)
            return p
          }),
          (s.remove = function (b) {
            if (b instanceof a) {
              this._remove(b, !1)
              var c = (b._timeline = b.vars.useFrames ? a._rootFramesTimeline : a._rootTimeline)
              return (b._startTime = (b._paused ? b._pauseTime : c._time) - (b._reversed ? b.totalDuration() - b._totalTime : b._totalTime) / b._timeScale), this
            }
            if (b instanceof Array || (b && b.push && i(b))) {
              for (var d = b.length; --d > -1; ) this.remove(b[d])
              return this
            }
            return 'string' == typeof b ? this.removeLabel(b) : this.kill(null, b)
          }),
          (s._remove = function (a, c) {
            b.prototype._remove.call(this, a, c)
            var d = this._last
            return (
              d
                ? this._time > this.duration() && ((this._time = this._duration), (this._totalTime = this._totalDuration))
                : (this._time = this._totalTime = this._duration = this._totalDuration = 0),
              this
            )
          }),
          (s.append = function (a, b) {
            return this.add(a, this._parseTimeOrLabel(null, b, !0, a))
          }),
          (s.insert = s.insertMultiple =
            function (a, b, c, d) {
              return this.add(a, b || 0, c, d)
            }),
          (s.appendMultiple = function (a, b, c, d) {
            return this.add(a, this._parseTimeOrLabel(null, b, !0, a), c, d)
          }),
          (s.addLabel = function (a, b) {
            return (this._labels[a] = this._parseTimeOrLabel(b)), this
          }),
          (s.addPause = function (a, b, d, e) {
            var f = c.delayedCall(0, o, d, e || this)
            return (f.vars.onComplete = f.vars.onReverseComplete = b), (f.data = 'isPause'), (this._hasPause = !0), this.add(f, a)
          }),
          (s.removeLabel = function (a) {
            return delete this._labels[a], this
          }),
          (s.getLabelTime = function (a) {
            return null != this._labels[a] ? this._labels[a] : -1
          }),
          (s._parseTimeOrLabel = function (b, c, d, e) {
            var f, g
            if (e instanceof a && e.timeline === this) this.remove(e)
            else if (e && (e instanceof Array || (e.push && i(e)))) for (g = e.length; --g > -1; ) e[g] instanceof a && e[g].timeline === this && this.remove(e[g])
            if (((f = 'number' != typeof b || c ? (this.duration() > 99999999999 ? this.recent().endTime(!1) : this._duration) : 0), 'string' == typeof c))
              return this._parseTimeOrLabel(c, d && 'number' == typeof b && null == this._labels[c] ? b - f : 0, d)
            if (((c = c || 0), 'string' != typeof b || (!isNaN(b) && null == this._labels[b]))) null == b && (b = f)
            else {
              if (((g = b.indexOf('=')), -1 === g)) return null == this._labels[b] ? (d ? (this._labels[b] = f + c) : c) : this._labels[b] + c
              ;(c = parseInt(b.charAt(g - 1) + '1', 10) * Number(b.substr(g + 1))), (b = g > 1 ? this._parseTimeOrLabel(b.substr(0, g - 1), 0, d) : f)
            }
            return Number(b) + c
          }),
          (s.seek = function (a, b) {
            return this.totalTime('number' == typeof a ? a : this._parseTimeOrLabel(a), b !== !1)
          }),
          (s.stop = function () {
            return this.paused(!0)
          }),
          (s.gotoAndPlay = function (a, b) {
            return this.play(a, b)
          }),
          (s.gotoAndStop = function (a, b) {
            return this.pause(a, b)
          }),
          (s.render = function (a, b, c) {
            this._gc && this._enabled(!0, !1)
            var d,
              f,
              g,
              h,
              i,
              l,
              m,
              n,
              o = this,
              p = o._time,
              q = o._dirty ? o.totalDuration() : o._totalDuration,
              r = o._startTime,
              s = o._timeScale,
              t = o._paused
            if ((p !== o._time && (a += o._time - p), a >= q - e && a >= 0))
              (o._totalTime = o._time = q),
                o._reversed ||
                  o._hasPausedChild() ||
                  ((f = !0),
                  (h = 'onComplete'),
                  (i = !!o._timeline.autoRemoveChildren),
                  0 === o._duration &&
                    ((0 >= a && a >= -e) || o._rawPrevTime < 0 || o._rawPrevTime === e) &&
                    o._rawPrevTime !== a &&
                    o._first &&
                    ((i = !0), o._rawPrevTime > e && (h = 'onReverseComplete'))),
                (o._rawPrevTime = o._duration || !b || a || o._rawPrevTime === a ? a : e),
                (a = q + 1e-4)
            else if (e > a)
              if (
                ((o._totalTime = o._time = 0),
                a > -e && (a = 0),
                (0 !== p || (0 === o._duration && o._rawPrevTime !== e && (o._rawPrevTime > 0 || (0 > a && o._rawPrevTime >= 0)))) &&
                  ((h = 'onReverseComplete'), (f = o._reversed)),
                0 > a)
              )
                (o._active = !1),
                  o._timeline.autoRemoveChildren && o._reversed ? ((i = f = !0), (h = 'onReverseComplete')) : o._rawPrevTime >= 0 && o._first && (i = !0),
                  (o._rawPrevTime = a)
              else {
                if (((o._rawPrevTime = o._duration || !b || a || o._rawPrevTime === a ? a : e), 0 === a && f))
                  for (d = o._first; d && 0 === d._startTime; ) d._duration || (f = !1), (d = d._next)
                ;(a = 0), o._initted || (i = !0)
              }
            else {
              if (o._hasPause && !o._forcingPlayhead && !b) {
                if (a >= p)
                  for (d = o._first; d && d._startTime <= a && !l; )
                    d._duration || 'isPause' !== d.data || d.ratio || (0 === d._startTime && 0 === o._rawPrevTime) || (l = d), (d = d._next)
                else for (d = o._last; d && d._startTime >= a && !l; ) d._duration || ('isPause' === d.data && d._rawPrevTime > 0 && (l = d)), (d = d._prev)
                l && ((o._time = o._totalTime = a = l._startTime), (n = o._startTime + a / o._timeScale))
              }
              o._totalTime = o._time = o._rawPrevTime = a
            }
            if ((o._time !== p && o._first) || c || i || l) {
              if (
                (o._initted || (o._initted = !0),
                o._active || (!o._paused && o._time !== p && a > 0 && (o._active = !0)),
                0 === p && o.vars.onStart && ((0 === o._time && o._duration) || b || o._callback('onStart')),
                (m = o._time),
                m >= p)
              )
                for (d = o._first; d && ((g = d._next), m === o._time && (!o._paused || t)); )
                  (d._active || (d._startTime <= m && !d._paused && !d._gc)) &&
                    (l === d && (o.pause(), (o._pauseTime = n)),
                    d._reversed
                      ? d.render((d._dirty ? d.totalDuration() : d._totalDuration) - (a - d._startTime) * d._timeScale, b, c)
                      : d.render((a - d._startTime) * d._timeScale, b, c)),
                    (d = g)
              else
                for (d = o._last; d && ((g = d._prev), m === o._time && (!o._paused || t)); ) {
                  if (d._active || (d._startTime <= p && !d._paused && !d._gc)) {
                    if (l === d) {
                      for (l = d._prev; l && l.endTime() > o._time; )
                        l.render(l._reversed ? l.totalDuration() - (a - l._startTime) * l._timeScale : (a - l._startTime) * l._timeScale, b, c), (l = l._prev)
                      ;(l = null), o.pause(), (o._pauseTime = n)
                    }
                    d._reversed
                      ? d.render((d._dirty ? d.totalDuration() : d._totalDuration) - (a - d._startTime) * d._timeScale, b, c)
                      : d.render((a - d._startTime) * d._timeScale, b, c)
                  }
                  d = g
                }
              o._onUpdate && (b || (j.length && k(), o._callback('onUpdate'))),
                h &&
                  (o._gc ||
                    ((r === o._startTime || s !== o._timeScale) &&
                      (0 === o._time || q >= o.totalDuration()) &&
                      (f && (j.length && k(), o._timeline.autoRemoveChildren && o._enabled(!1, !1), (o._active = !1)), !b && o.vars[h] && o._callback(h))))
            }
          }),
          (s._hasPausedChild = function () {
            for (var a = this._first; a; ) {
              if (a._paused || (a instanceof d && a._hasPausedChild())) return !0
              a = a._next
            }
            return !1
          }),
          (s.getChildren = function (a, b, d, e) {
            e = e || -9999999999
            for (var f = [], g = this._first, h = 0; g; )
              g._startTime < e ||
                (g instanceof c ? b !== !1 && (f[h++] = g) : (d !== !1 && (f[h++] = g), a !== !1 && ((f = f.concat(g.getChildren(!0, b, d))), (h = f.length)))),
                (g = g._next)
            return f
          }),
          (s.getTweensOf = function (a, b) {
            var d,
              e,
              f = this._gc,
              g = [],
              h = 0
            for (f && this._enabled(!0, !0), d = c.getTweensOf(a), e = d.length; --e > -1; ) (d[e].timeline === this || (b && this._contains(d[e]))) && (g[h++] = d[e])
            return f && this._enabled(!1, !0), g
          }),
          (s.recent = function () {
            return this._recent
          }),
          (s._contains = function (a) {
            for (var b = a.timeline; b; ) {
              if (b === this) return !0
              b = b.timeline
            }
            return !1
          }),
          (s.shiftChildren = function (a, b, c) {
            c = c || 0
            for (var d, e = this._first, f = this._labels; e; ) e._startTime >= c && (e._startTime += a), (e = e._next)
            if (b) for (d in f) f[d] >= c && (f[d] += a)
            return this._uncache(!0)
          }),
          (s._kill = function (a, b) {
            if (!a && !b) return this._enabled(!1, !1)
            for (var c = b ? this.getTweensOf(b) : this.getChildren(!0, !0, !1), d = c.length, e = !1; --d > -1; ) c[d]._kill(a, b) && (e = !0)
            return e
          }),
          (s.clear = function (a) {
            var b = this.getChildren(!1, !0, !0),
              c = b.length
            for (this._time = this._totalTime = 0; --c > -1; ) b[c]._enabled(!1, !1)
            return a !== !1 && (this._labels = {}), this._uncache(!0)
          }),
          (s.invalidate = function () {
            for (var b = this._first; b; ) b.invalidate(), (b = b._next)
            return a.prototype.invalidate.call(this)
          }),
          (s._enabled = function (a, c) {
            if (a === this._gc) for (var d = this._first; d; ) d._enabled(a, !0), (d = d._next)
            return b.prototype._enabled.call(this, a, c)
          }),
          (s.totalTime = function (b, c, d) {
            this._forcingPlayhead = !0
            var e = a.prototype.totalTime.apply(this, arguments)
            return (this._forcingPlayhead = !1), e
          }),
          (s.duration = function (a) {
            return arguments.length
              ? (0 !== this.duration() && 0 !== a && this.timeScale(this._duration / a), this)
              : (this._dirty && this.totalDuration(), this._duration)
          }),
          (s.totalDuration = function (a) {
            if (!arguments.length) {
              if (this._dirty) {
                for (var b, c, d = 0, e = this, f = e._last, g = 999999999999; f; )
                  (b = f._prev),
                    f._dirty && f.totalDuration(),
                    f._startTime > g && e._sortChildren && !f._paused && !e._calculatingDuration
                      ? ((e._calculatingDuration = 1), e.add(f, f._startTime - f._delay), (e._calculatingDuration = 0))
                      : (g = f._startTime),
                    f._startTime < 0 &&
                      !f._paused &&
                      ((d -= f._startTime),
                      e._timeline.smoothChildTiming &&
                        ((e._startTime += f._startTime / e._timeScale), (e._time -= f._startTime), (e._totalTime -= f._startTime), (e._rawPrevTime -= f._startTime)),
                      e.shiftChildren(-f._startTime, !1, -9999999999),
                      (g = 0)),
                    (c = f._startTime + f._totalDuration / f._timeScale),
                    c > d && (d = c),
                    (f = b)
                ;(e._duration = e._totalDuration = d), (e._dirty = !1)
              }
              return this._totalDuration
            }
            return a && this.totalDuration() ? this.timeScale(this._totalDuration / a) : this
          }),
          (s.paused = function (b) {
            if (b === !1 && this._paused) for (var c = this._first; c; ) c._startTime === this._time && 'isPause' === c.data && (c._rawPrevTime = 0), (c = c._next)
            return a.prototype.paused.apply(this, arguments)
          }),
          (s.usesFrames = function () {
            for (var b = this._timeline; b._timeline; ) b = b._timeline
            return b === a._rootFramesTimeline
          }),
          (s.rawTime = function (a) {
            return a && (this._paused || (this._repeat && this.time() > 0 && this.totalProgress() < 1))
              ? this._totalTime % (this._duration + this._repeatDelay)
              : this._paused
              ? this._totalTime
              : (this._timeline.rawTime(a) - this._startTime) * this._timeScale
          }),
          d
        )
      },
      !0
    ),
    _gsScope._gsDefine(
      'TimelineMax',
      ['TimelineLite', 'TweenLite', 'easing.Ease'],
      function (a, b, c) {
        var d = function (b) {
            a.call(this, b),
              (this._repeat = this.vars.repeat || 0),
              (this._repeatDelay = this.vars.repeatDelay || 0),
              (this._cycle = 0),
              (this._yoyo = !!this.vars.yoyo),
              (this._dirty = !0)
          },
          e = 1e-8,
          f = b._internals,
          g = f.lazyTweens,
          h = f.lazyRender,
          i = _gsScope._gsDefine.globals,
          j = new c(null, null, 1, 0),
          k = (d.prototype = new a())
        return (
          (k.constructor = d),
          (k.kill()._gc = !1),
          (d.version = '2.1.2'),
          (k.invalidate = function () {
            return (
              (this._yoyo = !!this.vars.yoyo),
              (this._repeat = this.vars.repeat || 0),
              (this._repeatDelay = this.vars.repeatDelay || 0),
              this._uncache(!0),
              a.prototype.invalidate.call(this)
            )
          }),
          (k.addCallback = function (a, c, d, e) {
            return this.add(b.delayedCall(0, a, d, e), c)
          }),
          (k.removeCallback = function (a, b) {
            if (a)
              if (null == b) this._kill(null, a)
              else for (var c = this.getTweensOf(a, !1), d = c.length, e = this._parseTimeOrLabel(b); --d > -1; ) c[d]._startTime === e && c[d]._enabled(!1, !1)
            return this
          }),
          (k.removePause = function (b) {
            return this.removeCallback(a._internals.pauseCallback, b)
          }),
          (k.tweenTo = function (a, c) {
            c = c || {}
            var d,
              e,
              f,
              g = { ease: j, useFrames: this.usesFrames(), immediateRender: !1, lazy: !1 },
              h = (c.repeat && i.TweenMax) || b
            for (e in c) g[e] = c[e]
            return (
              (g.time = this._parseTimeOrLabel(a)),
              (d = Math.abs(Number(g.time) - this._time) / this._timeScale || 0.001),
              (f = new h(this, d, g)),
              (g.onStart = function () {
                f.target.paused(!0),
                  f.vars.time === f.target.time() ||
                    d !== f.duration() ||
                    f.isFromTo ||
                    f.duration(Math.abs(f.vars.time - f.target.time()) / f.target._timeScale).render(f.time(), !0, !0),
                  c.onStart && c.onStart.apply(c.onStartScope || c.callbackScope || f, c.onStartParams || [])
              }),
              f
            )
          }),
          (k.tweenFromTo = function (a, b, c) {
            ;(c = c || {}),
              (a = this._parseTimeOrLabel(a)),
              (c.startAt = { onComplete: this.seek, onCompleteParams: [a], callbackScope: this }),
              (c.immediateRender = c.immediateRender !== !1)
            var d = this.tweenTo(b, c)
            return (d.isFromTo = 1), d.duration(Math.abs(d.vars.time - a) / this._timeScale || 0.001)
          }),
          (k.render = function (a, b, c) {
            this._gc && this._enabled(!0, !1)
            var d,
              f,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p = this,
              q = p._time,
              r = p._dirty ? p.totalDuration() : p._totalDuration,
              s = p._duration,
              t = p._totalTime,
              u = p._startTime,
              v = p._timeScale,
              w = p._rawPrevTime,
              x = p._paused,
              y = p._cycle
            if ((q !== p._time && (a += p._time - q), a >= r - e && a >= 0))
              p._locked || ((p._totalTime = r), (p._cycle = p._repeat)),
                p._reversed ||
                  p._hasPausedChild() ||
                  ((f = !0),
                  (j = 'onComplete'),
                  (k = !!p._timeline.autoRemoveChildren),
                  0 === p._duration && ((0 >= a && a >= -e) || 0 > w || w === e) && w !== a && p._first && ((k = !0), w > e && (j = 'onReverseComplete'))),
                (p._rawPrevTime = p._duration || !b || a || p._rawPrevTime === a ? a : e),
                p._yoyo && 1 & p._cycle ? (p._time = a = 0) : ((p._time = s), (a = s + 1e-4))
            else if (e > a)
              if (
                (p._locked || (p._totalTime = p._cycle = 0),
                (p._time = 0),
                a > -e && (a = 0),
                (0 !== q || (0 === s && w !== e && (w > 0 || (0 > a && w >= 0)) && !p._locked)) && ((j = 'onReverseComplete'), (f = p._reversed)),
                0 > a)
              )
                (p._active = !1),
                  p._timeline.autoRemoveChildren && p._reversed ? ((k = f = !0), (j = 'onReverseComplete')) : w >= 0 && p._first && (k = !0),
                  (p._rawPrevTime = a)
              else {
                if (((p._rawPrevTime = s || !b || a || p._rawPrevTime === a ? a : e), 0 === a && f))
                  for (d = p._first; d && 0 === d._startTime; ) d._duration || (f = !1), (d = d._next)
                ;(a = 0), p._initted || (k = !0)
              }
            else if (
              (0 === s && 0 > w && (k = !0),
              (p._time = p._rawPrevTime = a),
              p._locked ||
                ((p._totalTime = a),
                0 !== p._repeat &&
                  ((l = s + p._repeatDelay),
                  (p._cycle = (p._totalTime / l) >> 0),
                  p._cycle && p._cycle === p._totalTime / l && a >= t && p._cycle--,
                  (p._time = p._totalTime - p._cycle * l),
                  p._yoyo && 1 & p._cycle && (p._time = s - p._time),
                  p._time > s ? ((p._time = s), (a = s + 1e-4)) : p._time < 0 ? (p._time = a = 0) : (a = p._time))),
              p._hasPause && !p._forcingPlayhead && !b)
            ) {
              if (((a = p._time), a >= q || (p._repeat && y !== p._cycle)))
                for (d = p._first; d && d._startTime <= a && !m; )
                  d._duration || 'isPause' !== d.data || d.ratio || (0 === d._startTime && 0 === p._rawPrevTime) || (m = d), (d = d._next)
              else for (d = p._last; d && d._startTime >= a && !m; ) d._duration || ('isPause' === d.data && d._rawPrevTime > 0 && (m = d)), (d = d._prev)
              m &&
                ((o = p._startTime + m._startTime / p._timeScale),
                m._startTime < s && ((p._time = p._rawPrevTime = a = m._startTime), (p._totalTime = a + p._cycle * (p._totalDuration + p._repeatDelay))))
            }
            if (p._cycle !== y && !p._locked) {
              var z = p._yoyo && 0 !== (1 & y),
                A = z === (p._yoyo && 0 !== (1 & p._cycle)),
                B = p._totalTime,
                C = p._cycle,
                D = p._rawPrevTime,
                E = p._time
              if (
                ((p._totalTime = y * s),
                p._cycle < y ? (z = !z) : (p._totalTime += s),
                (p._time = q),
                (p._rawPrevTime = 0 === s ? w - 1e-4 : w),
                (p._cycle = y),
                (p._locked = !0),
                (q = z ? 0 : s),
                p.render(q, b, 0 === s),
                b || p._gc || (p.vars.onRepeat && ((p._cycle = C), (p._locked = !1), p._callback('onRepeat'))),
                q !== p._time)
              )
                return
              if ((A && ((p._cycle = y), (p._locked = !0), (q = z ? s + 1e-4 : -1e-4), p.render(q, !0, !1)), (p._locked = !1), p._paused && !x)) return
              ;(p._time = E), (p._totalTime = B), (p._cycle = C), (p._rawPrevTime = D)
            }
            if (!((p._time !== q && p._first) || c || k || m)) return void (t !== p._totalTime && p._onUpdate && (b || p._callback('onUpdate')))
            if (
              (p._initted || (p._initted = !0),
              p._active || (!p._paused && p._totalTime !== t && a > 0 && (p._active = !0)),
              0 === t && p.vars.onStart && ((0 === p._totalTime && p._totalDuration) || b || p._callback('onStart')),
              (n = p._time),
              n >= q)
            )
              for (d = p._first; d && ((i = d._next), n === p._time && (!p._paused || x)); )
                (d._active || (d._startTime <= p._time && !d._paused && !d._gc)) &&
                  (m === d && (p.pause(), (p._pauseTime = o)),
                  d._reversed
                    ? d.render((d._dirty ? d.totalDuration() : d._totalDuration) - (a - d._startTime) * d._timeScale, b, c)
                    : d.render((a - d._startTime) * d._timeScale, b, c)),
                  (d = i)
            else
              for (d = p._last; d && ((i = d._prev), n === p._time && (!p._paused || x)); ) {
                if (d._active || (d._startTime <= q && !d._paused && !d._gc)) {
                  if (m === d) {
                    for (m = d._prev; m && m.endTime() > p._time; )
                      m.render(m._reversed ? m.totalDuration() - (a - m._startTime) * m._timeScale : (a - m._startTime) * m._timeScale, b, c), (m = m._prev)
                    ;(m = null), p.pause(), (p._pauseTime = o)
                  }
                  d._reversed
                    ? d.render((d._dirty ? d.totalDuration() : d._totalDuration) - (a - d._startTime) * d._timeScale, b, c)
                    : d.render((a - d._startTime) * d._timeScale, b, c)
                }
                d = i
              }
            p._onUpdate && (b || (g.length && h(), p._callback('onUpdate'))),
              j &&
                (p._locked ||
                  p._gc ||
                  ((u === p._startTime || v !== p._timeScale) &&
                    (0 === p._time || r >= p.totalDuration()) &&
                    (f && (g.length && h(), p._timeline.autoRemoveChildren && p._enabled(!1, !1), (p._active = !1)), !b && p.vars[j] && p._callback(j))))
          }),
          (k.getActive = function (a, b, c) {
            var d,
              e,
              f = [],
              g = this.getChildren(a || null == a, b || null == a, !!c),
              h = 0,
              i = g.length
            for (d = 0; i > d; d++) (e = g[d]), e.isActive() && (f[h++] = e)
            return f
          }),
          (k.getLabelAfter = function (a) {
            a || (0 !== a && (a = this._time))
            var b,
              c = this.getLabelsArray(),
              d = c.length
            for (b = 0; d > b; b++) if (c[b].time > a) return c[b].name
            return null
          }),
          (k.getLabelBefore = function (a) {
            null == a && (a = this._time)
            for (var b = this.getLabelsArray(), c = b.length; --c > -1; ) if (b[c].time < a) return b[c].name
            return null
          }),
          (k.getLabelsArray = function () {
            var a,
              b = [],
              c = 0
            for (a in this._labels) b[c++] = { time: this._labels[a], name: a }
            return (
              b.sort(function (a, b) {
                return a.time - b.time
              }),
              b
            )
          }),
          (k.invalidate = function () {
            return (this._locked = !1), a.prototype.invalidate.call(this)
          }),
          (k.progress = function (a, b) {
            return arguments.length
              ? this.totalTime(this.duration() * (this._yoyo && 0 !== (1 & this._cycle) ? 1 - a : a) + this._cycle * (this._duration + this._repeatDelay), b)
              : this._time / this.duration() || 0
          }),
          (k.totalProgress = function (a, b) {
            return arguments.length ? this.totalTime(this.totalDuration() * a, b) : this._totalTime / this.totalDuration() || 0
          }),
          (k.totalDuration = function (b) {
            return arguments.length
              ? -1 !== this._repeat && b
                ? this.timeScale(this.totalDuration() / b)
                : this
              : (this._dirty &&
                  (a.prototype.totalDuration.call(this),
                  (this._totalDuration = -1 === this._repeat ? 999999999999 : this._duration * (this._repeat + 1) + this._repeatDelay * this._repeat)),
                this._totalDuration)
          }),
          (k.time = function (a, b) {
            if (!arguments.length) return this._time
            this._dirty && this.totalDuration()
            var c = this._duration,
              d = this._cycle,
              e = d * (c + this._repeatDelay)
            return a > c && (a = c), this.totalTime(this._yoyo && 1 & d ? c - a + e : this._repeat ? a + e : a, b)
          }),
          (k.repeat = function (a) {
            return arguments.length ? ((this._repeat = a), this._uncache(!0)) : this._repeat
          }),
          (k.repeatDelay = function (a) {
            return arguments.length ? ((this._repeatDelay = a), this._uncache(!0)) : this._repeatDelay
          }),
          (k.yoyo = function (a) {
            return arguments.length ? ((this._yoyo = a), this) : this._yoyo
          }),
          (k.currentLabel = function (a) {
            return arguments.length ? this.seek(a, !0) : this.getLabelBefore(this._time + e)
          }),
          d
        )
      },
      !0
    ),
    (function () {
      var a = 180 / Math.PI,
        b = [],
        c = [],
        d = [],
        e = {},
        f = _gsScope._gsDefine.globals,
        g = function (a, b, c, d) {
          c === d && (c = d - (d - b) / 1e6),
            a === b && (b = a + (c - a) / 1e6),
            (this.a = a),
            (this.b = b),
            (this.c = c),
            (this.d = d),
            (this.da = d - a),
            (this.ca = c - a),
            (this.ba = b - a)
        },
        h =
          ',x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,',
        i = function (a, b, c, d) {
          var e = { a: a },
            f = {},
            g = {},
            h = { c: d },
            i = (a + b) / 2,
            j = (b + c) / 2,
            k = (c + d) / 2,
            l = (i + j) / 2,
            m = (j + k) / 2,
            n = (m - l) / 8
          return (
            (e.b = i + (a - i) / 4),
            (f.b = l + n),
            (e.c = f.a = (e.b + f.b) / 2),
            (f.c = g.a = (l + m) / 2),
            (g.b = m - n),
            (h.b = k + (d - k) / 4),
            (g.c = h.a = (g.b + h.b) / 2),
            [e, f, g, h]
          )
        },
        j = function (a, e, f, g, h) {
          var j,
            k,
            l,
            m,
            n,
            o,
            p,
            q,
            r,
            s,
            t,
            u,
            v,
            w = a.length - 1,
            x = 0,
            y = a[0].a
          for (j = 0; w > j; j++)
            (n = a[x]),
              (k = n.a),
              (l = n.d),
              (m = a[x + 1].d),
              h
                ? ((t = b[j]),
                  (u = c[j]),
                  (v = ((u + t) * e * 0.25) / (g ? 0.5 : d[j] || 0.5)),
                  (o = l - (l - k) * (g ? 0.5 * e : 0 !== t ? v / t : 0)),
                  (p = l + (m - l) * (g ? 0.5 * e : 0 !== u ? v / u : 0)),
                  (q = l - (o + (((p - o) * ((3 * t) / (t + u) + 0.5)) / 4 || 0))))
                : ((o = l - (l - k) * e * 0.5), (p = l + (m - l) * e * 0.5), (q = l - (o + p) / 2)),
              (o += q),
              (p += q),
              (n.c = r = o),
              0 !== j ? (n.b = y) : (n.b = y = n.a + 0.6 * (n.c - n.a)),
              (n.da = l - k),
              (n.ca = r - k),
              (n.ba = y - k),
              f ? ((s = i(k, y, r, l)), a.splice(x, 1, s[0], s[1], s[2], s[3]), (x += 4)) : x++,
              (y = p)
          ;(n = a[x]),
            (n.b = y),
            (n.c = y + 0.4 * (n.d - y)),
            (n.da = n.d - n.a),
            (n.ca = n.c - n.a),
            (n.ba = y - n.a),
            f && ((s = i(n.a, y, n.c, n.d)), a.splice(x, 1, s[0], s[1], s[2], s[3]))
        },
        k = function (a, d, e, f) {
          var h,
            i,
            j,
            k,
            l,
            m,
            n = []
          if (f)
            for (a = [f].concat(a), i = a.length; --i > -1; )
              'string' == typeof (m = a[i][d]) && '=' === m.charAt(1) && (a[i][d] = f[d] + Number(m.charAt(0) + m.substr(2)))
          if (((h = a.length - 2), 0 > h)) return (n[0] = new g(a[0][d], 0, 0, a[0][d])), n
          for (i = 0; h > i; i++)
            (j = a[i][d]),
              (k = a[i + 1][d]),
              (n[i] = new g(j, 0, 0, k)),
              e && ((l = a[i + 2][d]), (b[i] = (b[i] || 0) + (k - j) * (k - j)), (c[i] = (c[i] || 0) + (l - k) * (l - k)))
          return (n[i] = new g(a[i][d], 0, 0, a[i + 1][d])), n
        },
        l = function (a, f, g, i, l, m) {
          var n,
            o,
            p,
            q,
            r,
            s,
            t,
            u,
            v = {},
            w = [],
            x = m || a[0]
          ;(l = 'string' == typeof l ? ',' + l + ',' : h), null == f && (f = 1)
          for (o in a[0]) w.push(o)
          if (a.length > 1) {
            for (u = a[a.length - 1], t = !0, n = w.length; --n > -1; )
              if (((o = w[n]), Math.abs(x[o] - u[o]) > 0.05)) {
                t = !1
                break
              }
            t && ((a = a.concat()), m && a.unshift(m), a.push(a[1]), (m = a[a.length - 3]))
          }
          for (b.length = c.length = d.length = 0, n = w.length; --n > -1; ) (o = w[n]), (e[o] = -1 !== l.indexOf(',' + o + ',')), (v[o] = k(a, o, e[o], m))
          for (n = b.length; --n > -1; ) (b[n] = Math.sqrt(b[n])), (c[n] = Math.sqrt(c[n]))
          if (!i) {
            for (n = w.length; --n > -1; )
              if (e[o]) for (p = v[w[n]], s = p.length - 1, q = 0; s > q; q++) (r = p[q + 1].da / c[q] + p[q].da / b[q] || 0), (d[q] = (d[q] || 0) + r * r)
            for (n = d.length; --n > -1; ) d[n] = Math.sqrt(d[n])
          }
          for (n = w.length, q = g ? 4 : 1; --n > -1; ) (o = w[n]), (p = v[o]), j(p, f, g, i, e[o]), t && (p.splice(0, q), p.splice(p.length - q, q))
          return v
        },
        m = function (a, b, c) {
          b = b || 'soft'
          var d,
            e,
            f,
            h,
            i,
            j,
            k,
            l,
            m,
            n,
            o,
            p = {},
            q = 'cubic' === b ? 3 : 2,
            r = 'soft' === b,
            s = []
          if ((r && c && (a = [c].concat(a)), null == a || a.length < q + 1)) throw 'invalid Bezier data'
          for (m in a[0]) s.push(m)
          for (j = s.length; --j > -1; ) {
            for (m = s[j], p[m] = i = [], n = 0, l = a.length, k = 0; l > k; k++)
              (d = null == c ? a[k][m] : 'string' == typeof (o = a[k][m]) && '=' === o.charAt(1) ? c[m] + Number(o.charAt(0) + o.substr(2)) : Number(o)),
                r && k > 1 && l - 1 > k && (i[n++] = (d + i[n - 2]) / 2),
                (i[n++] = d)
            for (l = n - q + 1, n = 0, k = 0; l > k; k += q)
              (d = i[k]),
                (e = i[k + 1]),
                (f = i[k + 2]),
                (h = 2 === q ? 0 : i[k + 3]),
                (i[n++] = o = 3 === q ? new g(d, e, f, h) : new g(d, (2 * e + d) / 3, (2 * e + f) / 3, f))
            i.length = n
          }
          return p
        },
        n = function (a, b, c) {
          for (var d, e, f, g, h, i, j, k, l, m, n, o = 1 / c, p = a.length; --p > -1; )
            for (m = a[p], f = m.a, g = m.d - f, h = m.c - f, i = m.b - f, d = e = 0, k = 1; c >= k; k++)
              (j = o * k), (l = 1 - j), (d = e - (e = (j * j * g + 3 * l * (j * h + l * i)) * j)), (n = p * c + k - 1), (b[n] = (b[n] || 0) + d * d)
        },
        o = function (a, b) {
          b = b >> 0 || 6
          var c,
            d,
            e,
            f,
            g = [],
            h = [],
            i = 0,
            j = 0,
            k = b - 1,
            l = [],
            m = []
          for (c in a) n(a[c], g, b)
          for (e = g.length, d = 0; e > d; d++)
            (i += Math.sqrt(g[d])), (f = d % b), (m[f] = i), f === k && ((j += i), (f = (d / b) >> 0), (l[f] = m), (h[f] = j), (i = 0), (m = []))
          return { length: j, lengths: h, segments: l }
        },
        p = _gsScope._gsDefine.plugin({
          propName: 'bezier',
          priority: -1,
          version: '1.3.8',
          API: 2,
          global: !0,
          init: function (a, b, c) {
            ;(this._target = a),
              b instanceof Array && (b = { values: b }),
              (this._func = {}),
              (this._mod = {}),
              (this._props = []),
              (this._timeRes = null == b.timeResolution ? 6 : parseInt(b.timeResolution, 10))
            var d,
              e,
              f,
              g,
              h,
              i = b.values || [],
              j = {},
              k = i[0],
              n = b.autoRotate || c.vars.orientToBezier
            this._autoRotate = n ? (n instanceof Array ? n : [['x', 'y', 'rotation', n === !0 ? 0 : Number(n) || 0]]) : null
            for (d in k) this._props.push(d)
            for (f = this._props.length; --f > -1; )
              (d = this._props[f]),
                this._overwriteProps.push(d),
                (e = this._func[d] = 'function' == typeof a[d]),
                (j[d] = e ? a[d.indexOf('set') || 'function' != typeof a['get' + d.substr(3)] ? d : 'get' + d.substr(3)]() : parseFloat(a[d])),
                h || (j[d] !== i[0][d] && (h = j))
            if (
              ((this._beziers =
                'cubic' !== b.type && 'quadratic' !== b.type && 'soft' !== b.type
                  ? l(i, isNaN(b.curviness) ? 1 : b.curviness, !1, 'thruBasic' === b.type, b.correlate, h)
                  : m(i, b.type, j)),
              (this._segCount = this._beziers[d].length),
              this._timeRes)
            ) {
              var p = o(this._beziers, this._timeRes)
              ;(this._length = p.length),
                (this._lengths = p.lengths),
                (this._segments = p.segments),
                (this._l1 = this._li = this._s1 = this._si = 0),
                (this._l2 = this._lengths[0]),
                (this._curSeg = this._segments[0]),
                (this._s2 = this._curSeg[0]),
                (this._prec = 1 / this._curSeg.length)
            }
            if ((n = this._autoRotate))
              for (this._initialRotations = [], n[0] instanceof Array || (this._autoRotate = n = [n]), f = n.length; --f > -1; ) {
                for (g = 0; 3 > g; g++)
                  (d = n[f][g]),
                    (this._func[d] = 'function' == typeof a[d] ? a[d.indexOf('set') || 'function' != typeof a['get' + d.substr(3)] ? d : 'get' + d.substr(3)] : !1)
                ;(d = n[f][2]), (this._initialRotations[f] = (this._func[d] ? this._func[d].call(this._target) : this._target[d]) || 0), this._overwriteProps.push(d)
              }
            return (this._startRatio = c.vars.runBackwards ? 1 : 0), !0
          },
          set: function (b) {
            var c,
              d,
              e,
              f,
              g,
              h,
              i,
              j,
              k,
              l,
              m = this._segCount,
              n = this._func,
              o = this._target,
              p = b !== this._startRatio
            if (this._timeRes) {
              if (((k = this._lengths), (l = this._curSeg), (b *= this._length), (e = this._li), b > this._l2 && m - 1 > e)) {
                for (j = m - 1; j > e && (this._l2 = k[++e]) <= b; );
                ;(this._l1 = k[e - 1]), (this._li = e), (this._curSeg = l = this._segments[e]), (this._s2 = l[(this._s1 = this._si = 0)])
              } else if (b < this._l1 && e > 0) {
                for (; e > 0 && (this._l1 = k[--e]) >= b; );
                0 === e && b < this._l1 ? (this._l1 = 0) : e++,
                  (this._l2 = k[e]),
                  (this._li = e),
                  (this._curSeg = l = this._segments[e]),
                  (this._s1 = l[(this._si = l.length - 1) - 1] || 0),
                  (this._s2 = l[this._si])
              }
              if (((c = e), (b -= this._l1), (e = this._si), b > this._s2 && e < l.length - 1)) {
                for (j = l.length - 1; j > e && (this._s2 = l[++e]) <= b; );
                ;(this._s1 = l[e - 1]), (this._si = e)
              } else if (b < this._s1 && e > 0) {
                for (; e > 0 && (this._s1 = l[--e]) >= b; );
                0 === e && b < this._s1 ? (this._s1 = 0) : e++, (this._s2 = l[e]), (this._si = e)
              }
              h = (e + (b - this._s1) / (this._s2 - this._s1)) * this._prec || 0
            } else (c = 0 > b ? 0 : b >= 1 ? m - 1 : (m * b) >> 0), (h = (b - c * (1 / m)) * m)
            for (d = 1 - h, e = this._props.length; --e > -1; )
              (f = this._props[e]),
                (g = this._beziers[f][c]),
                (i = (h * h * g.da + 3 * d * (h * g.ca + d * g.ba)) * h + g.a),
                this._mod[f] && (i = this._mod[f](i, o)),
                n[f] ? o[f](i) : (o[f] = i)
            if (this._autoRotate) {
              var q,
                r,
                s,
                t,
                u,
                v,
                w,
                x = this._autoRotate
              for (e = x.length; --e > -1; )
                (f = x[e][2]),
                  (v = x[e][3] || 0),
                  (w = x[e][4] === !0 ? 1 : a),
                  (g = this._beziers[x[e][0]]),
                  (q = this._beziers[x[e][1]]),
                  g &&
                    q &&
                    ((g = g[c]),
                    (q = q[c]),
                    (r = g.a + (g.b - g.a) * h),
                    (t = g.b + (g.c - g.b) * h),
                    (r += (t - r) * h),
                    (t += (g.c + (g.d - g.c) * h - t) * h),
                    (s = q.a + (q.b - q.a) * h),
                    (u = q.b + (q.c - q.b) * h),
                    (s += (u - s) * h),
                    (u += (q.c + (q.d - q.c) * h - u) * h),
                    (i = p ? Math.atan2(u - s, t - r) * w + v : this._initialRotations[e]),
                    this._mod[f] && (i = this._mod[f](i, o)),
                    n[f] ? o[f](i) : (o[f] = i))
            }
          }
        }),
        q = p.prototype
      ;(p.bezierThrough = l),
        (p.cubicToQuadratic = i),
        (p._autoCSS = !0),
        (p.quadraticToCubic = function (a, b, c) {
          return new g(a, (2 * b + a) / 3, (2 * b + c) / 3, c)
        }),
        (p._cssRegister = function () {
          var a = f.CSSPlugin
          if (a) {
            var b = a._internals,
              c = b._parseToProxy,
              d = b._setPluginRatio,
              e = b.CSSPropTween
            b._registerComplexSpecialProp('bezier', {
              parser: function (a, b, f, g, h, i) {
                b instanceof Array && (b = { values: b }), (i = new p())
                var j,
                  k,
                  l,
                  m = b.values,
                  n = m.length - 1,
                  o = [],
                  q = {}
                if (0 > n) return h
                for (j = 0; n >= j; j++) (l = c(a, m[j], g, h, i, n !== j)), (o[j] = l.end)
                for (k in b) q[k] = b[k]
                return (
                  (q.values = o),
                  (h = new e(a, 'bezier', 0, 0, l.pt, 2)),
                  (h.data = l),
                  (h.plugin = i),
                  (h.setRatio = d),
                  0 === q.autoRotate && (q.autoRotate = !0),
                  !q.autoRotate ||
                    q.autoRotate instanceof Array ||
                    ((j = q.autoRotate === !0 ? 0 : Number(q.autoRotate)),
                    (q.autoRotate = null != l.end.left ? [['left', 'top', 'rotation', j, !1]] : null != l.end.x ? [['x', 'y', 'rotation', j, !1]] : !1)),
                  q.autoRotate &&
                    (g._transform || g._enableTransforms(!1),
                    (l.autoRotate = g._target._gsTransform),
                    (l.proxy.rotation = l.autoRotate.rotation || 0),
                    g._overwriteProps.push('rotation')),
                  i._onInitTween(l.proxy, q, g._tween),
                  h
                )
              }
            })
          }
        }),
        (q._mod = function (a) {
          for (var b, c = this._overwriteProps, d = c.length; --d > -1; ) (b = a[c[d]]), b && 'function' == typeof b && (this._mod[c[d]] = b)
        }),
        (q._kill = function (a) {
          var b,
            c,
            d = this._props
          for (b in this._beziers) if (b in a) for (delete this._beziers[b], delete this._func[b], c = d.length; --c > -1; ) d[c] === b && d.splice(c, 1)
          if ((d = this._autoRotate)) for (c = d.length; --c > -1; ) a[d[c][2]] && d.splice(c, 1)
          return this._super._kill.call(this, a)
        })
    })(),
    _gsScope._gsDefine(
      'plugins.CSSPlugin',
      ['plugins.TweenPlugin', 'TweenLite'],
      function (a, b) {
        var c,
          d,
          e,
          f,
          g = function () {
            a.call(this, 'css'), (this._overwriteProps.length = 0), (this.setRatio = g.prototype.setRatio)
          },
          h = _gsScope._gsDefine.globals,
          i = {},
          j = (g.prototype = new a('css'))
        ;(j.constructor = g),
          (g.version = '2.1.0'),
          (g.API = 2),
          (g.defaultTransformPerspective = 0),
          (g.defaultSkewType = 'compensated'),
          (g.defaultSmoothOrigin = !0),
          (j = 'px'),
          (g.suffixMap = { top: j, right: j, bottom: j, left: j, width: j, height: j, fontSize: j, padding: j, margin: j, perspective: j, lineHeight: '' })
        var k,
          l,
          m,
          n,
          o,
          p,
          q,
          r,
          s = /(?:\-|\.|\b)(\d|\.|e\-)+/g,
          t = /(?:\d|\-\d|\.\d|\-\.\d|\+=\d|\-=\d|\+=.\d|\-=\.\d)+/g,
          u = /(?:\+=|\-=|\-|\b)[\d\-\.]+[a-zA-Z0-9]*(?:%|\b)/gi,
          v = /(?![+-]?\d*\.?\d+|[+-]|e[+-]\d+)[^0-9]/g,
          w = /(?:\d|\-|\+|=|#|\.)*/g,
          x = /opacity *= *([^)]*)/i,
          y = /opacity:([^;]*)/i,
          z = /alpha\(opacity *=.+?\)/i,
          A = /^(rgb|hsl)/,
          B = /([A-Z])/g,
          C = /-([a-z])/gi,
          D = /(^(?:url\(\"|url\())|(?:(\"\))$|\)$)/gi,
          E = function (a, b) {
            return b.toUpperCase()
          },
          F = /(?:Left|Right|Width)/i,
          G = /(M11|M12|M21|M22)=[\d\-\.e]+/gi,
          H = /progid\:DXImageTransform\.Microsoft\.Matrix\(.+?\)/i,
          I = /,(?=[^\)]*(?:\(|$))/gi,
          J = /[\s,\(]/i,
          K = Math.PI / 180,
          L = 180 / Math.PI,
          M = {},
          N = { style: {} },
          O = _gsScope.document || {
            createElement: function () {
              return N
            }
          },
          P = function (a, b) {
            return b && O.createElementNS ? O.createElementNS(b, a) : O.createElement(a)
          },
          Q = P('div'),
          R = P('img'),
          S = (g._internals = { _specialProps: i }),
          T = (_gsScope.navigator || {}).userAgent || '',
          U = (function () {
            var a = T.indexOf('Android'),
              b = P('a')
            return (
              (m = -1 !== T.indexOf('Safari') && -1 === T.indexOf('Chrome') && (-1 === a || parseFloat(T.substr(a + 8, 2)) > 3)),
              (o = m && parseFloat(T.substr(T.indexOf('Version/') + 8, 2)) < 6),
              (n = -1 !== T.indexOf('Firefox')),
              (/MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(T) || /Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(T)) && (p = parseFloat(RegExp.$1)),
              b ? ((b.style.cssText = 'top:1px;opacity:.55;'), /^0.55/.test(b.style.opacity)) : !1
            )
          })(),
          V = function (a) {
            return x.test('string' == typeof a ? a : (a.currentStyle ? a.currentStyle.filter : a.style.filter) || '') ? parseFloat(RegExp.$1) / 100 : 1
          },
          W = function (a) {
            _gsScope.console && console.log(a)
          },
          X = '',
          Y = '',
          Z = function (a, b) {
            b = b || Q
            var c,
              d,
              e = b.style
            if (void 0 !== e[a]) return a
            for (a = a.charAt(0).toUpperCase() + a.substr(1), c = ['O', 'Moz', 'ms', 'Ms', 'Webkit'], d = 5; --d > -1 && void 0 === e[c[d] + a]; );
            return d >= 0 ? ((Y = 3 === d ? 'ms' : c[d]), (X = '-' + Y.toLowerCase() + '-'), Y + a) : null
          },
          $ = 'undefined' != typeof window ? window : O.defaultView || { getComputedStyle: function () {} },
          _ = function (a) {
            return $.getComputedStyle(a)
          },
          aa = (g.getStyle = function (a, b, c, d, e) {
            var f
            return U || 'opacity' !== b
              ? (!d && a.style[b]
                  ? (f = a.style[b])
                  : (c = c || _(a))
                  ? (f = c[b] || c.getPropertyValue(b) || c.getPropertyValue(b.replace(B, '-$1').toLowerCase()))
                  : a.currentStyle && (f = a.currentStyle[b]),
                null == e || (f && 'none' !== f && 'auto' !== f && 'auto auto' !== f) ? f : e)
              : V(a)
          }),
          ba = (S.convertToPixels = function (a, c, d, e, f) {
            if ('px' === e || (!e && 'lineHeight' !== c)) return d
            if ('auto' === e || !d) return 0
            var h,
              i,
              j,
              k = F.test(c),
              l = a,
              m = Q.style,
              n = 0 > d,
              o = 1 === d
            if ((n && (d = -d), o && (d *= 100), 'lineHeight' !== c || e))
              if ('%' === e && -1 !== c.indexOf('border')) h = (d / 100) * (k ? a.clientWidth : a.clientHeight)
              else {
                if (
                  ((m.cssText = 'border:0 solid red;position:' + aa(a, 'position') + ';line-height:0;'), '%' !== e && l.appendChild && 'v' !== e.charAt(0) && 'rem' !== e)
                )
                  m[k ? 'borderLeftWidth' : 'borderTopWidth'] = d + e
                else {
                  if (
                    ((l = a.parentNode || O.body),
                    -1 !== aa(l, 'display').indexOf('flex') && (m.position = 'absolute'),
                    (i = l._gsCache),
                    (j = b.ticker.frame),
                    i && k && i.time === j)
                  )
                    return (i.width * d) / 100
                  m[k ? 'width' : 'height'] = d + e
                }
                l.appendChild(Q),
                  (h = parseFloat(Q[k ? 'offsetWidth' : 'offsetHeight'])),
                  l.removeChild(Q),
                  k && '%' === e && g.cacheWidths !== !1 && ((i = l._gsCache = l._gsCache || {}), (i.time = j), (i.width = (h / d) * 100)),
                  0 !== h || f || (h = ba(a, c, d, e, !0))
              }
            else (i = _(a).lineHeight), (a.style.lineHeight = d), (h = parseFloat(_(a).lineHeight)), (a.style.lineHeight = i)
            return o && (h /= 100), n ? -h : h
          }),
          ca = (S.calculateOffset = function (a, b, c) {
            if ('absolute' !== aa(a, 'position', c)) return 0
            var d = 'left' === b ? 'Left' : 'Top',
              e = aa(a, 'margin' + d, c)
            return a['offset' + d] - (ba(a, b, parseFloat(e), e.replace(w, '')) || 0)
          }),
          da = function (a, b) {
            var c,
              d,
              e,
              f = {}
            if ((b = b || _(a, null)))
              if ((c = b.length)) for (; --c > -1; ) (e = b[c]), (-1 === e.indexOf('-transform') || Ea === e) && (f[e.replace(C, E)] = b.getPropertyValue(e))
              else for (c in b) (-1 === c.indexOf('Transform') || Da === c) && (f[c] = b[c])
            else if ((b = a.currentStyle || a.style)) for (c in b) 'string' == typeof c && void 0 === f[c] && (f[c.replace(C, E)] = b[c])
            return (
              U || (f.opacity = V(a)),
              (d = Sa(a, b, !1)),
              (f.rotation = d.rotation),
              (f.skewX = d.skewX),
              (f.scaleX = d.scaleX),
              (f.scaleY = d.scaleY),
              (f.x = d.x),
              (f.y = d.y),
              Ga && ((f.z = d.z), (f.rotationX = d.rotationX), (f.rotationY = d.rotationY), (f.scaleZ = d.scaleZ)),
              f.filters && delete f.filters,
              f
            )
          },
          ea = function (a, b, c, d, e) {
            var f,
              g,
              h,
              i = {},
              j = a.style
            for (g in c)
              'cssText' !== g &&
                'length' !== g &&
                isNaN(g) &&
                (b[g] !== (f = c[g]) || (e && e[g])) &&
                -1 === g.indexOf('Origin') &&
                ('number' == typeof f || 'string' == typeof f) &&
                ((i[g] =
                  'auto' !== f || ('left' !== g && 'top' !== g)
                    ? ('' !== f && 'auto' !== f && 'none' !== f) || 'string' != typeof b[g] || '' === b[g].replace(v, '')
                      ? f
                      : 0
                    : ca(a, g)),
                void 0 !== j[g] && (h = new ta(j, g, j[g], h)))
            if (d) for (g in d) 'className' !== g && (i[g] = d[g])
            return { difs: i, firstMPT: h }
          },
          fa = { width: ['Left', 'Right'], height: ['Top', 'Bottom'] },
          ga = ['marginLeft', 'marginRight', 'marginTop', 'marginBottom'],
          ha = function (a, b, c) {
            if ('svg' === (a.nodeName + '').toLowerCase()) return (c || _(a))[b] || 0
            if (a.getCTM && Pa(a)) return a.getBBox()[b] || 0
            var d = parseFloat('width' === b ? a.offsetWidth : a.offsetHeight),
              e = fa[b],
              f = e.length
            for (c = c || _(a, null); --f > -1; ) (d -= parseFloat(aa(a, 'padding' + e[f], c, !0)) || 0), (d -= parseFloat(aa(a, 'border' + e[f] + 'Width', c, !0)) || 0)
            return d
          },
          ia = function (a, b) {
            if ('contain' === a || 'auto' === a || 'auto auto' === a) return a + ' '
            ;(null == a || '' === a) && (a = '0 0')
            var c,
              d = a.split(' '),
              e = -1 !== a.indexOf('left') ? '0%' : -1 !== a.indexOf('right') ? '100%' : d[0],
              f = -1 !== a.indexOf('top') ? '0%' : -1 !== a.indexOf('bottom') ? '100%' : d[1]
            if (d.length > 3 && !b) {
              for (d = a.split(', ').join(',').split(','), a = [], c = 0; c < d.length; c++) a.push(ia(d[c]))
              return a.join(',')
            }
            return (
              null == f ? (f = 'center' === e ? '50%' : '0') : 'center' === f && (f = '50%'),
              ('center' === e || (isNaN(parseFloat(e)) && -1 === (e + '').indexOf('='))) && (e = '50%'),
              (a = e + ' ' + f + (d.length > 2 ? ' ' + d[2] : '')),
              b &&
                ((b.oxp = -1 !== e.indexOf('%')),
                (b.oyp = -1 !== f.indexOf('%')),
                (b.oxr = '=' === e.charAt(1)),
                (b.oyr = '=' === f.charAt(1)),
                (b.ox = parseFloat(e.replace(v, ''))),
                (b.oy = parseFloat(f.replace(v, ''))),
                (b.v = a)),
              b || a
            )
          },
          ja = function (a, b) {
            return (
              'function' == typeof a && (a = a(r, q)),
              'string' == typeof a && '=' === a.charAt(1) ? parseInt(a.charAt(0) + '1', 10) * parseFloat(a.substr(2)) : parseFloat(a) - parseFloat(b) || 0
            )
          },
          ka = function (a, b) {
            'function' == typeof a && (a = a(r, q))
            var c = 'string' == typeof a && '=' === a.charAt(1)
            return (
              'string' == typeof a &&
                'v' === a.charAt(a.length - 2) &&
                (a = (c ? a.substr(0, 2) : 0) + window['inner' + ('vh' === a.substr(-2) ? 'Height' : 'Width')] * (parseFloat(c ? a.substr(2) : a) / 100)),
              null == a ? b : c ? parseInt(a.charAt(0) + '1', 10) * parseFloat(a.substr(2)) + b : parseFloat(a) || 0
            )
          },
          la = function (a, b, c, d) {
            var e,
              f,
              g,
              h,
              i,
              j = 1e-6
            return (
              'function' == typeof a && (a = a(r, q)),
              null == a
                ? (h = b)
                : 'number' == typeof a
                ? (h = a)
                : ((e = 360),
                  (f = a.split('_')),
                  (i = '=' === a.charAt(1)),
                  (g = (i ? parseInt(a.charAt(0) + '1', 10) * parseFloat(f[0].substr(2)) : parseFloat(f[0])) * (-1 === a.indexOf('rad') ? 1 : L) - (i ? 0 : b)),
                  f.length &&
                    (d && (d[c] = b + g),
                    -1 !== a.indexOf('short') && ((g %= e), g !== g % (e / 2) && (g = 0 > g ? g + e : g - e)),
                    -1 !== a.indexOf('_cw') && 0 > g
                      ? (g = ((g + 9999999999 * e) % e) - ((g / e) | 0) * e)
                      : -1 !== a.indexOf('ccw') && g > 0 && (g = ((g - 9999999999 * e) % e) - ((g / e) | 0) * e)),
                  (h = b + g)),
              j > h && h > -j && (h = 0),
              h
            )
          },
          ma = {
            aqua: [0, 255, 255],
            lime: [0, 255, 0],
            silver: [192, 192, 192],
            black: [0, 0, 0],
            maroon: [128, 0, 0],
            teal: [0, 128, 128],
            blue: [0, 0, 255],
            navy: [0, 0, 128],
            white: [255, 255, 255],
            fuchsia: [255, 0, 255],
            olive: [128, 128, 0],
            yellow: [255, 255, 0],
            orange: [255, 165, 0],
            gray: [128, 128, 128],
            purple: [128, 0, 128],
            green: [0, 128, 0],
            red: [255, 0, 0],
            pink: [255, 192, 203],
            cyan: [0, 255, 255],
            transparent: [255, 255, 255, 0]
          },
          na = function (a, b, c) {
            return (
              (a = 0 > a ? a + 1 : a > 1 ? a - 1 : a), (255 * (1 > 6 * a ? b + (c - b) * a * 6 : 0.5 > a ? c : 2 > 3 * a ? b + (c - b) * (2 / 3 - a) * 6 : b) + 0.5) | 0
            )
          },
          oa = (g.parseColor = function (a, b) {
            var c, d, e, f, g, h, i, j, k, l, m
            if (a)
              if ('number' == typeof a) c = [a >> 16, (a >> 8) & 255, 255 & a]
              else {
                if ((',' === a.charAt(a.length - 1) && (a = a.substr(0, a.length - 1)), ma[a])) c = ma[a]
                else if ('#' === a.charAt(0))
                  4 === a.length && ((d = a.charAt(1)), (e = a.charAt(2)), (f = a.charAt(3)), (a = '#' + d + d + e + e + f + f)),
                    (a = parseInt(a.substr(1), 16)),
                    (c = [a >> 16, (a >> 8) & 255, 255 & a])
                else if ('hsl' === a.substr(0, 3))
                  if (((c = m = a.match(s)), b)) {
                    if (-1 !== a.indexOf('=')) return a.match(t)
                  } else
                    (g = (Number(c[0]) % 360) / 360),
                      (h = Number(c[1]) / 100),
                      (i = Number(c[2]) / 100),
                      (e = 0.5 >= i ? i * (h + 1) : i + h - i * h),
                      (d = 2 * i - e),
                      c.length > 3 && (c[3] = Number(c[3])),
                      (c[0] = na(g + 1 / 3, d, e)),
                      (c[1] = na(g, d, e)),
                      (c[2] = na(g - 1 / 3, d, e))
                else c = a.match(s) || ma.transparent
                ;(c[0] = Number(c[0])), (c[1] = Number(c[1])), (c[2] = Number(c[2])), c.length > 3 && (c[3] = Number(c[3]))
              }
            else c = ma.black
            return (
              b &&
                !m &&
                ((d = c[0] / 255),
                (e = c[1] / 255),
                (f = c[2] / 255),
                (j = Math.max(d, e, f)),
                (k = Math.min(d, e, f)),
                (i = (j + k) / 2),
                j === k
                  ? (g = h = 0)
                  : ((l = j - k),
                    (h = i > 0.5 ? l / (2 - j - k) : l / (j + k)),
                    (g = j === d ? (e - f) / l + (f > e ? 6 : 0) : j === e ? (f - d) / l + 2 : (d - e) / l + 4),
                    (g *= 60)),
                (c[0] = (g + 0.5) | 0),
                (c[1] = (100 * h + 0.5) | 0),
                (c[2] = (100 * i + 0.5) | 0)),
              c
            )
          }),
          pa = function (a, b) {
            var c,
              d,
              e,
              f = a.match(qa) || [],
              g = 0,
              h = ''
            if (!f.length) return a
            for (c = 0; c < f.length; c++)
              (d = f[c]),
                (e = a.substr(g, a.indexOf(d, g) - g)),
                (g += e.length + d.length),
                (d = oa(d, b)),
                3 === d.length && d.push(1),
                (h += e + (b ? 'hsla(' + d[0] + ',' + d[1] + '%,' + d[2] + '%,' + d[3] : 'rgba(' + d.join(',')) + ')')
            return h + a.substr(g)
          },
          qa = '(?:\\b(?:(?:rgb|rgba|hsl|hsla)\\(.+?\\))|\\B#(?:[0-9a-f]{3}){1,2}\\b'
        for (j in ma) qa += '|' + j + '\\b'
        ;(qa = new RegExp(qa + ')', 'gi')),
          (g.colorStringFilter = function (a) {
            var b,
              c = a[0] + ' ' + a[1]
            qa.test(c) && ((b = -1 !== c.indexOf('hsl(') || -1 !== c.indexOf('hsla(')), (a[0] = pa(a[0], b)), (a[1] = pa(a[1], b))), (qa.lastIndex = 0)
          }),
          b.defaultStringFilter || (b.defaultStringFilter = g.colorStringFilter)
        var ra = function (a, b, c, d) {
            if (null == a)
              return function (a) {
                return a
              }
            var e,
              f = b ? (a.match(qa) || [''])[0] : '',
              g = a.split(f).join('').match(u) || [],
              h = a.substr(0, a.indexOf(g[0])),
              i = ')' === a.charAt(a.length - 1) ? ')' : '',
              j = -1 !== a.indexOf(' ') ? ' ' : ',',
              k = g.length,
              l = k > 0 ? g[0].replace(s, '') : ''
            return k
              ? (e = b
                  ? function (a) {
                      var b, m, n, o
                      if ('number' == typeof a) a += l
                      else if (d && I.test(a)) {
                        for (o = a.replace(I, '|').split('|'), n = 0; n < o.length; n++) o[n] = e(o[n])
                        return o.join(',')
                      }
                      if (((b = (a.match(qa) || [f])[0]), (m = a.split(b).join('').match(u) || []), (n = m.length), k > n--))
                        for (; ++n < k; ) m[n] = c ? m[((n - 1) / 2) | 0] : g[n]
                      return h + m.join(j) + j + b + i + (-1 !== a.indexOf('inset') ? ' inset' : '')
                    }
                  : function (a) {
                      var b, f, m
                      if ('number' == typeof a) a += l
                      else if (d && I.test(a)) {
                        for (f = a.replace(I, '|').split('|'), m = 0; m < f.length; m++) f[m] = e(f[m])
                        return f.join(',')
                      }
                      if (((b = a.match(u) || []), (m = b.length), k > m--)) for (; ++m < k; ) b[m] = c ? b[((m - 1) / 2) | 0] : g[m]
                      return h + b.join(j) + i
                    })
              : function (a) {
                  return a
                }
          },
          sa = function (a) {
            return (
              (a = a.split(',')),
              function (b, c, d, e, f, g, h) {
                var i,
                  j = (c + '').split(' ')
                for (h = {}, i = 0; 4 > i; i++) h[a[i]] = j[i] = j[i] || j[((i - 1) / 2) >> 0]
                return e.parse(b, h, f, g)
              }
            )
          },
          ta =
            ((S._setPluginRatio = function (a) {
              this.plugin.setRatio(a)
              for (var b, c, d, e, f, g = this.data, h = g.proxy, i = g.firstMPT, j = 1e-6; i; )
                (b = h[i.v]), i.r ? (b = i.r(b)) : j > b && b > -j && (b = 0), (i.t[i.p] = b), (i = i._next)
              if ((g.autoRotate && (g.autoRotate.rotation = g.mod ? g.mod.call(this._tween, h.rotation, this.t, this._tween) : h.rotation), 1 === a || 0 === a))
                for (i = g.firstMPT, f = 1 === a ? 'e' : 'b'; i; ) {
                  if (((c = i.t), c.type)) {
                    if (1 === c.type) {
                      for (e = c.xs0 + c.s + c.xs1, d = 1; d < c.l; d++) e += c['xn' + d] + c['xs' + (d + 1)]
                      c[f] = e
                    }
                  } else c[f] = c.s + c.xs0
                  i = i._next
                }
            }),
            function (a, b, c, d, e) {
              ;(this.t = a), (this.p = b), (this.v = c), (this.r = e), d && ((d._prev = this), (this._next = d))
            }),
          ua =
            ((S._parseToProxy = function (a, b, c, d, e, f) {
              var g,
                h,
                i,
                j,
                k,
                l = d,
                m = {},
                n = {},
                o = c._transform,
                p = M
              for (
                c._transform = null, M = b, d = k = c.parse(a, b, d, e), M = p, f && ((c._transform = o), l && ((l._prev = null), l._prev && (l._prev._next = null)));
                d && d !== l;

              ) {
                if (d.type <= 1 && ((h = d.p), (n[h] = d.s + d.c), (m[h] = d.s), f || ((j = new ta(d, 's', h, j, d.r)), (d.c = 0)), 1 === d.type))
                  for (g = d.l; --g > 0; ) (i = 'xn' + g), (h = d.p + '_' + i), (n[h] = d.data[i]), (m[h] = d[i]), f || (j = new ta(d, i, h, j, d.rxp[i]))
                d = d._next
              }
              return { proxy: m, end: n, firstMPT: j, pt: k }
            }),
            (S.CSSPropTween = function (a, b, d, e, g, h, i, j, k, l, m) {
              ;(this.t = a),
                (this.p = b),
                (this.s = d),
                (this.c = e),
                (this.n = i || b),
                a instanceof ua || f.push(this.n),
                (this.r = j ? ('function' == typeof j ? j : Math.round) : j),
                (this.type = h || 0),
                k && ((this.pr = k), (c = !0)),
                (this.b = void 0 === l ? d : l),
                (this.e = void 0 === m ? d + e : m),
                g && ((this._next = g), (g._prev = this))
            })),
          va = function (a, b, c, d, e, f) {
            var g = new ua(a, b, c, d - c, e, -1, f)
            return (g.b = c), (g.e = g.xs0 = d), g
          },
          wa = (g.parseComplex = function (a, b, c, d, e, f, h, i, j, l) {
            ;(c = c || f || ''),
              'function' == typeof d && (d = d(r, q)),
              (h = new ua(a, b, 0, 0, h, l ? 2 : 1, null, !1, i, c, d)),
              (d += ''),
              e && qa.test(d + c) && ((d = [c, d]), g.colorStringFilter(d), (c = d[0]), (d = d[1]))
            var m,
              n,
              o,
              p,
              u,
              v,
              w,
              x,
              y,
              z,
              A,
              B,
              C,
              D = c.split(', ').join(',').split(' '),
              E = d.split(', ').join(',').split(' '),
              F = D.length,
              G = k !== !1
            for (
              (-1 !== d.indexOf(',') || -1 !== c.indexOf(',')) &&
                (-1 !== (d + c).indexOf('rgb') || -1 !== (d + c).indexOf('hsl')
                  ? ((D = D.join(' ').replace(I, ', ').split(' ')), (E = E.join(' ').replace(I, ', ').split(' ')))
                  : ((D = D.join(' ').split(',').join(', ').split(' ')), (E = E.join(' ').split(',').join(', ').split(' '))),
                (F = D.length)),
                F !== E.length && ((D = (f || '').split(' ')), (F = D.length)),
                h.plugin = j,
                h.setRatio = l,
                qa.lastIndex = 0,
                m = 0;
              F > m;
              m++
            )
              if (((p = D[m]), (u = E[m] + ''), (x = parseFloat(p)), x || 0 === x))
                h.appendXtra('', x, ja(u, x), u.replace(t, ''), G && -1 !== u.indexOf('px') ? Math.round : !1, !0)
              else if (e && qa.test(p))
                (B = u.indexOf(')') + 1),
                  (B = ')' + (B ? u.substr(B) : '')),
                  (C = -1 !== u.indexOf('hsl') && U),
                  (z = u),
                  (p = oa(p, C)),
                  (u = oa(u, C)),
                  (y = p.length + u.length > 6),
                  y && !U && 0 === u[3]
                    ? ((h['xs' + h.l] += h.l ? ' transparent' : 'transparent'), (h.e = h.e.split(E[m]).join('transparent')))
                    : (U || (y = !1),
                      C
                        ? h
                            .appendXtra(z.substr(0, z.indexOf('hsl')) + (y ? 'hsla(' : 'hsl('), p[0], ja(u[0], p[0]), ',', !1, !0)
                            .appendXtra('', p[1], ja(u[1], p[1]), '%,', !1)
                            .appendXtra('', p[2], ja(u[2], p[2]), y ? '%,' : '%' + B, !1)
                        : h
                            .appendXtra(z.substr(0, z.indexOf('rgb')) + (y ? 'rgba(' : 'rgb('), p[0], u[0] - p[0], ',', Math.round, !0)
                            .appendXtra('', p[1], u[1] - p[1], ',', Math.round)
                            .appendXtra('', p[2], u[2] - p[2], y ? ',' : B, Math.round),
                      y && ((p = p.length < 4 ? 1 : p[3]), h.appendXtra('', p, (u.length < 4 ? 1 : u[3]) - p, B, !1))),
                  (qa.lastIndex = 0)
              else if ((v = p.match(s))) {
                if (((w = u.match(t)), !w || w.length !== v.length)) return h
                for (o = 0, n = 0; n < v.length; n++)
                  (A = v[n]),
                    (z = p.indexOf(A, o)),
                    h.appendXtra(p.substr(o, z - o), Number(A), ja(w[n], A), '', G && 'px' === p.substr(z + A.length, 2) ? Math.round : !1, 0 === n),
                    (o = z + A.length)
                h['xs' + h.l] += p.substr(o)
              } else h['xs' + h.l] += h.l || h['xs' + h.l] ? ' ' + u : u
            if (-1 !== d.indexOf('=') && h.data) {
              for (B = h.xs0 + h.data.s, m = 1; m < h.l; m++) B += h['xs' + m] + h.data['xn' + m]
              h.e = B + h['xs' + m]
            }
            return h.l || ((h.type = -1), (h.xs0 = h.e)), h.xfirst || h
          }),
          xa = 9
        for (j = ua.prototype, j.l = j.pr = 0; --xa > 0; ) (j['xn' + xa] = 0), (j['xs' + xa] = '')
        ;(j.xs0 = ''),
          (j._next = j._prev = j.xfirst = j.data = j.plugin = j.setRatio = j.rxp = null),
          (j.appendXtra = function (a, b, c, d, e, f) {
            var g = this,
              h = g.l
            return (
              (g['xs' + h] += f && (h || g['xs' + h]) ? ' ' + a : a || ''),
              c || 0 === h || g.plugin
                ? (g.l++,
                  (g.type = g.setRatio ? 2 : 1),
                  (g['xs' + g.l] = d || ''),
                  h > 0
                    ? ((g.data['xn' + h] = b + c),
                      (g.rxp['xn' + h] = e),
                      (g['xn' + h] = b),
                      g.plugin || ((g.xfirst = new ua(g, 'xn' + h, b, c, g.xfirst || g, 0, g.n, e, g.pr)), (g.xfirst.xs0 = 0)),
                      g)
                    : ((g.data = { s: b + c }), (g.rxp = {}), (g.s = b), (g.c = c), (g.r = e), g))
                : ((g['xs' + h] += b + (d || '')), g)
            )
          })
        var ya = function (a, b) {
            ;(b = b || {}),
              (this.p = b.prefix ? Z(a) || a : a),
              (i[a] = i[this.p] = this),
              (this.format = b.formatter || ra(b.defaultValue, b.color, b.collapsible, b.multi)),
              b.parser && (this.parse = b.parser),
              (this.clrs = b.color),
              (this.multi = b.multi),
              (this.keyword = b.keyword),
              (this.dflt = b.defaultValue),
              (this.allowFunc = b.allowFunc),
              (this.pr = b.priority || 0)
          },
          za = (S._registerComplexSpecialProp = function (a, b, c) {
            'object' != typeof b && (b = { parser: c })
            var d,
              e,
              f = a.split(','),
              g = b.defaultValue
            for (c = c || [g], d = 0; d < f.length; d++) (b.prefix = 0 === d && b.prefix), (b.defaultValue = c[d] || g), (e = new ya(f[d], b))
          }),
          Aa = (S._registerPluginProp = function (a) {
            if (!i[a]) {
              var b = a.charAt(0).toUpperCase() + a.substr(1) + 'Plugin'
              za(a, {
                parser: function (a, c, d, e, f, g, j) {
                  var k = h.com.greensock.plugins[b]
                  return k ? (k._cssRegister(), i[d].parse(a, c, d, e, f, g, j)) : (W('Error: ' + b + ' js file not loaded.'), f)
                }
              })
            }
          })
        ;(j = ya.prototype),
          (j.parseComplex = function (a, b, c, d, e, f) {
            var g,
              h,
              i,
              j,
              k,
              l,
              m = this.keyword
            if ((this.multi && (I.test(c) || I.test(b) ? ((h = b.replace(I, '|').split('|')), (i = c.replace(I, '|').split('|'))) : m && ((h = [b]), (i = [c]))), i)) {
              for (j = i.length > h.length ? i.length : h.length, g = 0; j > g; g++)
                (b = h[g] = h[g] || this.dflt),
                  (c = i[g] = i[g] || this.dflt),
                  m && ((k = b.indexOf(m)), (l = c.indexOf(m)), k !== l && (-1 === l ? (h[g] = h[g].split(m).join('')) : -1 === k && (h[g] += ' ' + m)))
              ;(b = h.join(', ')), (c = i.join(', '))
            }
            return wa(a, this.p, b, c, this.clrs, this.dflt, d, this.pr, e, f)
          }),
          (j.parse = function (a, b, c, d, f, g, h) {
            return this.parseComplex(a.style, this.format(aa(a, this.p, e, !1, this.dflt)), this.format(b), f, g)
          }),
          (g.registerSpecialProp = function (a, b, c) {
            za(a, {
              parser: function (a, d, e, f, g, h, i) {
                var j = new ua(a, e, 0, 0, g, 2, e, !1, c)
                return (j.plugin = h), (j.setRatio = b(a, d, f._tween, e)), j
              },
              priority: c
            })
          }),
          (g.useSVGTransformAttr = !0)
        var Ba,
          Ca = 'scaleX,scaleY,scaleZ,x,y,z,skewX,skewY,rotation,rotationX,rotationY,perspective,xPercent,yPercent'.split(','),
          Da = Z('transform'),
          Ea = X + 'transform',
          Fa = Z('transformOrigin'),
          Ga = null !== Z('perspective'),
          Ha = (S.Transform = function () {
            ;(this.perspective = parseFloat(g.defaultTransformPerspective) || 0), (this.force3D = g.defaultForce3D !== !1 && Ga ? g.defaultForce3D || 'auto' : !1)
          }),
          Ia = _gsScope.SVGElement,
          Ja = function (a, b, c) {
            var d,
              e = O.createElementNS('http://www.w3.org/2000/svg', a),
              f = /([a-z])([A-Z])/g
            for (d in c) e.setAttributeNS(null, d.replace(f, '$1-$2').toLowerCase(), c[d])
            return b.appendChild(e), e
          },
          Ka = O.documentElement || {},
          La = (function () {
            var a,
              b,
              c,
              d = p || (/Android/i.test(T) && !_gsScope.chrome)
            return (
              O.createElementNS &&
                !d &&
                ((a = Ja('svg', Ka)),
                (b = Ja('rect', a, { width: 100, height: 50, x: 100 })),
                (c = b.getBoundingClientRect().width),
                (b.style[Fa] = '50% 50%'),
                (b.style[Da] = 'scaleX(0.5)'),
                (d = c === b.getBoundingClientRect().width && !(n && Ga)),
                Ka.removeChild(a)),
              d
            )
          })(),
          Ma = function (a, b, c, d, e, f) {
            var h,
              i,
              j,
              k,
              l,
              m,
              n,
              o,
              p,
              q,
              r,
              s,
              t,
              u,
              v = a._gsTransform,
              w = Ra(a, !0)
            v && ((t = v.xOrigin), (u = v.yOrigin)),
              (!d || (h = d.split(' ')).length < 2) &&
                ((n = a.getBBox()),
                0 === n.x &&
                  0 === n.y &&
                  n.width + n.height === 0 &&
                  (n = {
                    x: parseFloat(a.hasAttribute('x') ? a.getAttribute('x') : a.hasAttribute('cx') ? a.getAttribute('cx') : 0) || 0,
                    y: parseFloat(a.hasAttribute('y') ? a.getAttribute('y') : a.hasAttribute('cy') ? a.getAttribute('cy') : 0) || 0,
                    width: 0,
                    height: 0
                  }),
                (b = ia(b).split(' ')),
                (h = [
                  (-1 !== b[0].indexOf('%') ? (parseFloat(b[0]) / 100) * n.width : parseFloat(b[0])) + n.x,
                  (-1 !== b[1].indexOf('%') ? (parseFloat(b[1]) / 100) * n.height : parseFloat(b[1])) + n.y
                ])),
              (c.xOrigin = k = parseFloat(h[0])),
              (c.yOrigin = l = parseFloat(h[1])),
              d &&
                w !== Qa &&
                ((m = w[0]),
                (n = w[1]),
                (o = w[2]),
                (p = w[3]),
                (q = w[4]),
                (r = w[5]),
                (s = m * p - n * o),
                s &&
                  ((i = k * (p / s) + l * (-o / s) + (o * r - p * q) / s),
                  (j = k * (-n / s) + l * (m / s) - (m * r - n * q) / s),
                  (k = c.xOrigin = h[0] = i),
                  (l = c.yOrigin = h[1] = j))),
              v &&
                (f && ((c.xOffset = v.xOffset), (c.yOffset = v.yOffset), (v = c)),
                e || (e !== !1 && g.defaultSmoothOrigin !== !1)
                  ? ((i = k - t), (j = l - u), (v.xOffset += i * w[0] + j * w[2] - i), (v.yOffset += i * w[1] + j * w[3] - j))
                  : (v.xOffset = v.yOffset = 0)),
              f || a.setAttribute('data-svg-origin', h.join(' '))
          },
          Na = function (a) {
            var b,
              c = P('svg', (this.ownerSVGElement && this.ownerSVGElement.getAttribute('xmlns')) || 'http://www.w3.org/2000/svg'),
              d = this.parentNode,
              e = this.nextSibling,
              f = this.style.cssText
            if ((Ka.appendChild(c), c.appendChild(this), (this.style.display = 'block'), a))
              try {
                ;(b = this.getBBox()), (this._originalGetBBox = this.getBBox), (this.getBBox = Na)
              } catch (g) {}
            else this._originalGetBBox && (b = this._originalGetBBox())
            return e ? d.insertBefore(this, e) : d.appendChild(this), Ka.removeChild(c), (this.style.cssText = f), b
          },
          Oa = function (a) {
            try {
              return a.getBBox()
            } catch (b) {
              return Na.call(a, !0)
            }
          },
          Pa = function (a) {
            return !(!Ia || !a.getCTM || (a.parentNode && !a.ownerSVGElement) || !Oa(a))
          },
          Qa = [1, 0, 0, 1, 0, 0],
          Ra = function (a, b) {
            var c,
              d,
              e,
              f,
              g,
              h,
              i,
              j = a._gsTransform || new Ha(),
              k = 1e5,
              l = a.style
            if (
              (Da
                ? (d = aa(a, Ea, null, !0))
                : a.currentStyle &&
                  ((d = a.currentStyle.filter.match(G)),
                  (d = d && 4 === d.length ? [d[0].substr(4), Number(d[2].substr(4)), Number(d[1].substr(4)), d[3].substr(4), j.x || 0, j.y || 0].join(',') : '')),
              (c = !d || 'none' === d || 'matrix(1, 0, 0, 1, 0, 0)' === d),
              Da &&
                c &&
                !a.offsetParent &&
                ((f = l.display),
                (l.display = 'block'),
                (i = a.parentNode),
                (i && a.offsetParent) || ((g = 1), (h = a.nextSibling), Ka.appendChild(a)),
                (d = aa(a, Ea, null, !0)),
                (c = !d || 'none' === d || 'matrix(1, 0, 0, 1, 0, 0)' === d),
                f ? (l.display = f) : Wa(l, 'display'),
                g && (h ? i.insertBefore(a, h) : i ? i.appendChild(a) : Ka.removeChild(a))),
              (j.svg || (a.getCTM && Pa(a))) &&
                (c && -1 !== (l[Da] + '').indexOf('matrix') && ((d = l[Da]), (c = 0)),
                (e = a.getAttribute('transform')),
                c &&
                  e &&
                  ((e = a.transform.baseVal.consolidate().matrix), (d = 'matrix(' + e.a + ',' + e.b + ',' + e.c + ',' + e.d + ',' + e.e + ',' + e.f + ')'), (c = 0))),
              c)
            )
              return Qa
            for (e = (d || '').match(s) || [], xa = e.length; --xa > -1; )
              (f = Number(e[xa])), (e[xa] = (g = f - (f |= 0)) ? ((g * k + (0 > g ? -0.5 : 0.5)) | 0) / k + f : f)
            return b && e.length > 6 ? [e[0], e[1], e[4], e[5], e[12], e[13]] : e
          },
          Sa = (S.getTransform = function (a, c, d, e) {
            if (a._gsTransform && d && !e) return a._gsTransform
            var f,
              h,
              i,
              j,
              k,
              l,
              m = d ? a._gsTransform || new Ha() : new Ha(),
              n = m.scaleX < 0,
              o = 2e-5,
              p = 1e5,
              q = Ga ? parseFloat(aa(a, Fa, c, !1, '0 0 0').split(' ')[2]) || m.zOrigin || 0 : 0,
              r = parseFloat(g.defaultTransformPerspective) || 0
            if (
              ((m.svg = !(!a.getCTM || !Pa(a))),
              m.svg && (Ma(a, aa(a, Fa, c, !1, '50% 50%') + '', m, a.getAttribute('data-svg-origin')), (Ba = g.useSVGTransformAttr || La)),
              (f = Ra(a)),
              f !== Qa)
            ) {
              if (16 === f.length) {
                var s,
                  t,
                  u,
                  v,
                  w,
                  x = f[0],
                  y = f[1],
                  z = f[2],
                  A = f[3],
                  B = f[4],
                  C = f[5],
                  D = f[6],
                  E = f[7],
                  F = f[8],
                  G = f[9],
                  H = f[10],
                  I = f[12],
                  J = f[13],
                  K = f[14],
                  M = f[11],
                  N = Math.atan2(D, H)
                m.zOrigin && ((K = -m.zOrigin), (I = F * K - f[12]), (J = G * K - f[13]), (K = H * K + m.zOrigin - f[14])),
                  (m.rotationX = N * L),
                  N &&
                    ((v = Math.cos(-N)),
                    (w = Math.sin(-N)),
                    (s = B * v + F * w),
                    (t = C * v + G * w),
                    (u = D * v + H * w),
                    (F = B * -w + F * v),
                    (G = C * -w + G * v),
                    (H = D * -w + H * v),
                    (M = E * -w + M * v),
                    (B = s),
                    (C = t),
                    (D = u)),
                  (N = Math.atan2(-z, H)),
                  (m.rotationY = N * L),
                  N &&
                    ((v = Math.cos(-N)),
                    (w = Math.sin(-N)),
                    (s = x * v - F * w),
                    (t = y * v - G * w),
                    (u = z * v - H * w),
                    (G = y * w + G * v),
                    (H = z * w + H * v),
                    (M = A * w + M * v),
                    (x = s),
                    (y = t),
                    (z = u)),
                  (N = Math.atan2(y, x)),
                  (m.rotation = N * L),
                  N &&
                    ((v = Math.cos(N)),
                    (w = Math.sin(N)),
                    (s = x * v + y * w),
                    (t = B * v + C * w),
                    (u = F * v + G * w),
                    (y = y * v - x * w),
                    (C = C * v - B * w),
                    (G = G * v - F * w),
                    (x = s),
                    (B = t),
                    (F = u)),
                  m.rotationX && Math.abs(m.rotationX) + Math.abs(m.rotation) > 359.9 && ((m.rotationX = m.rotation = 0), (m.rotationY = 180 - m.rotationY)),
                  (N = Math.atan2(B, C)),
                  (m.scaleX = ((Math.sqrt(x * x + y * y + z * z) * p + 0.5) | 0) / p),
                  (m.scaleY = ((Math.sqrt(C * C + D * D) * p + 0.5) | 0) / p),
                  (m.scaleZ = ((Math.sqrt(F * F + G * G + H * H) * p + 0.5) | 0) / p),
                  (x /= m.scaleX),
                  (B /= m.scaleY),
                  (y /= m.scaleX),
                  (C /= m.scaleY),
                  Math.abs(N) > o ? ((m.skewX = N * L), (B = 0), 'simple' !== m.skewType && (m.scaleY *= 1 / Math.cos(N))) : (m.skewX = 0),
                  (m.perspective = M ? 1 / (0 > M ? -M : M) : 0),
                  (m.x = I),
                  (m.y = J),
                  (m.z = K),
                  m.svg && ((m.x -= m.xOrigin - (m.xOrigin * x - m.yOrigin * B)), (m.y -= m.yOrigin - (m.yOrigin * y - m.xOrigin * C)))
              } else if (!Ga || e || !f.length || m.x !== f[4] || m.y !== f[5] || (!m.rotationX && !m.rotationY)) {
                var O = f.length >= 6,
                  P = O ? f[0] : 1,
                  Q = f[1] || 0,
                  R = f[2] || 0,
                  S = O ? f[3] : 1
                ;(m.x = f[4] || 0),
                  (m.y = f[5] || 0),
                  (i = Math.sqrt(P * P + Q * Q)),
                  (j = Math.sqrt(S * S + R * R)),
                  (k = P || Q ? Math.atan2(Q, P) * L : m.rotation || 0),
                  (l = R || S ? Math.atan2(R, S) * L + k : m.skewX || 0),
                  (m.scaleX = i),
                  (m.scaleY = j),
                  (m.rotation = k),
                  (m.skewX = l),
                  Ga && ((m.rotationX = m.rotationY = m.z = 0), (m.perspective = r), (m.scaleZ = 1)),
                  m.svg && ((m.x -= m.xOrigin - (m.xOrigin * P + m.yOrigin * R)), (m.y -= m.yOrigin - (m.xOrigin * Q + m.yOrigin * S)))
              }
              Math.abs(m.skewX) > 90 &&
                Math.abs(m.skewX) < 270 &&
                (n
                  ? ((m.scaleX *= -1), (m.skewX += m.rotation <= 0 ? 180 : -180), (m.rotation += m.rotation <= 0 ? 180 : -180))
                  : ((m.scaleY *= -1), (m.skewX += m.skewX <= 0 ? 180 : -180))),
                (m.zOrigin = q)
              for (h in m) m[h] < o && m[h] > -o && (m[h] = 0)
            }
            return (
              d &&
                ((a._gsTransform = m),
                m.svg &&
                  (Ba && a.style[Da]
                    ? b.delayedCall(0.001, function () {
                        Wa(a.style, Da)
                      })
                    : !Ba &&
                      a.getAttribute('transform') &&
                      b.delayedCall(0.001, function () {
                        a.removeAttribute('transform')
                      }))),
              m
            )
          }),
          Ta = function (a) {
            var b,
              c,
              d = this.data,
              e = -d.rotation * K,
              f = e + d.skewX * K,
              g = 1e5,
              h = ((Math.cos(e) * d.scaleX * g) | 0) / g,
              i = ((Math.sin(e) * d.scaleX * g) | 0) / g,
              j = ((Math.sin(f) * -d.scaleY * g) | 0) / g,
              k = ((Math.cos(f) * d.scaleY * g) | 0) / g,
              l = this.t.style,
              m = this.t.currentStyle
            if (m) {
              ;(c = i), (i = -j), (j = -c), (b = m.filter), (l.filter = '')
              var n,
                o,
                q = this.t.offsetWidth,
                r = this.t.offsetHeight,
                s = 'absolute' !== m.position,
                t = 'progid:DXImageTransform.Microsoft.Matrix(M11=' + h + ', M12=' + i + ', M21=' + j + ', M22=' + k,
                u = d.x + (q * d.xPercent) / 100,
                v = d.y + (r * d.yPercent) / 100
              if (
                (null != d.ox &&
                  ((n = (d.oxp ? q * d.ox * 0.01 : d.ox) - q / 2),
                  (o = (d.oyp ? r * d.oy * 0.01 : d.oy) - r / 2),
                  (u += n - (n * h + o * i)),
                  (v += o - (n * j + o * k))),
                s
                  ? ((n = q / 2), (o = r / 2), (t += ', Dx=' + (n - (n * h + o * i) + u) + ', Dy=' + (o - (n * j + o * k) + v) + ')'))
                  : (t += ", sizingMethod='auto expand')"),
                -1 !== b.indexOf('DXImageTransform.Microsoft.Matrix(') ? (l.filter = b.replace(H, t)) : (l.filter = t + ' ' + b),
                (0 === a || 1 === a) &&
                  1 === h &&
                  0 === i &&
                  0 === j &&
                  1 === k &&
                  ((s && -1 === t.indexOf('Dx=0, Dy=0')) ||
                    (x.test(b) && 100 !== parseFloat(RegExp.$1)) ||
                    (-1 === b.indexOf(b.indexOf('Alpha')) && l.removeAttribute('filter'))),
                !s)
              ) {
                var y,
                  z,
                  A,
                  B = 8 > p ? 1 : -1
                for (
                  n = d.ieOffsetX || 0,
                    o = d.ieOffsetY || 0,
                    d.ieOffsetX = Math.round((q - ((0 > h ? -h : h) * q + (0 > i ? -i : i) * r)) / 2 + u),
                    d.ieOffsetY = Math.round((r - ((0 > k ? -k : k) * r + (0 > j ? -j : j) * q)) / 2 + v),
                    xa = 0;
                  4 > xa;
                  xa++
                )
                  (z = ga[xa]),
                    (y = m[z]),
                    (c = -1 !== y.indexOf('px') ? parseFloat(y) : ba(this.t, z, parseFloat(y), y.replace(w, '')) || 0),
                    (A = c !== d[z] ? (2 > xa ? -d.ieOffsetX : -d.ieOffsetY) : 2 > xa ? n - d.ieOffsetX : o - d.ieOffsetY),
                    (l[z] = (d[z] = Math.round(c - A * (0 === xa || 2 === xa ? 1 : B))) + 'px')
              }
            }
          },
          Ua =
            (S.set3DTransformRatio =
            S.setTransformRatio =
              function (a) {
                var b,
                  c,
                  d,
                  e,
                  f,
                  g,
                  h,
                  i,
                  j,
                  k,
                  l,
                  m,
                  o,
                  p,
                  q,
                  r,
                  s,
                  t,
                  u,
                  v,
                  w,
                  x,
                  y,
                  z = this.data,
                  A = this.t.style,
                  B = z.rotation,
                  C = z.rotationX,
                  D = z.rotationY,
                  E = z.scaleX,
                  F = z.scaleY,
                  G = z.scaleZ,
                  H = z.x,
                  I = z.y,
                  J = z.z,
                  L = z.svg,
                  M = z.perspective,
                  N = z.force3D,
                  O = z.skewY,
                  P = z.skewX
                if (
                  (O && ((P += O), (B += O)),
                  ((((1 === a || 0 === a) && 'auto' === N && (this.tween._totalTime === this.tween._totalDuration || !this.tween._totalTime)) || !N) &&
                    !J &&
                    !M &&
                    !D &&
                    !C &&
                    1 === G) ||
                    (Ba && L) ||
                    !Ga)
                )
                  return void (B || P || L
                    ? ((B *= K),
                      (x = P * K),
                      (y = 1e5),
                      (c = Math.cos(B) * E),
                      (f = Math.sin(B) * E),
                      (d = Math.sin(B - x) * -F),
                      (g = Math.cos(B - x) * F),
                      x &&
                        'simple' === z.skewType &&
                        ((b = Math.tan(x - O * K)),
                        (b = Math.sqrt(1 + b * b)),
                        (d *= b),
                        (g *= b),
                        O && ((b = Math.tan(O * K)), (b = Math.sqrt(1 + b * b)), (c *= b), (f *= b))),
                      L &&
                        ((H += z.xOrigin - (z.xOrigin * c + z.yOrigin * d) + z.xOffset),
                        (I += z.yOrigin - (z.xOrigin * f + z.yOrigin * g) + z.yOffset),
                        Ba && (z.xPercent || z.yPercent) && ((q = this.t.getBBox()), (H += 0.01 * z.xPercent * q.width), (I += 0.01 * z.yPercent * q.height)),
                        (q = 1e-6),
                        q > H && H > -q && (H = 0),
                        q > I && I > -q && (I = 0)),
                      (u = ((c * y) | 0) / y + ',' + ((f * y) | 0) / y + ',' + ((d * y) | 0) / y + ',' + ((g * y) | 0) / y + ',' + H + ',' + I + ')'),
                      L && Ba
                        ? this.t.setAttribute('transform', 'matrix(' + u)
                        : (A[Da] = (z.xPercent || z.yPercent ? 'translate(' + z.xPercent + '%,' + z.yPercent + '%) matrix(' : 'matrix(') + u))
                    : (A[Da] =
                        (z.xPercent || z.yPercent ? 'translate(' + z.xPercent + '%,' + z.yPercent + '%) matrix(' : 'matrix(') +
                        E +
                        ',0,0,' +
                        F +
                        ',' +
                        H +
                        ',' +
                        I +
                        ')'))
                if ((n && ((q = 1e-4), q > E && E > -q && (E = G = 2e-5), q > F && F > -q && (F = G = 2e-5), !M || z.z || z.rotationX || z.rotationY || (M = 0)), B || P))
                  (B *= K),
                    (r = c = Math.cos(B)),
                    (s = f = Math.sin(B)),
                    P &&
                      ((B -= P * K),
                      (r = Math.cos(B)),
                      (s = Math.sin(B)),
                      'simple' === z.skewType &&
                        ((b = Math.tan((P - O) * K)),
                        (b = Math.sqrt(1 + b * b)),
                        (r *= b),
                        (s *= b),
                        z.skewY && ((b = Math.tan(O * K)), (b = Math.sqrt(1 + b * b)), (c *= b), (f *= b)))),
                    (d = -s),
                    (g = r)
                else {
                  if (!(D || C || 1 !== G || M || L))
                    return void (A[Da] =
                      (z.xPercent || z.yPercent ? 'translate(' + z.xPercent + '%,' + z.yPercent + '%) translate3d(' : 'translate3d(') +
                      H +
                      'px,' +
                      I +
                      'px,' +
                      J +
                      'px)' +
                      (1 !== E || 1 !== F ? ' scale(' + E + ',' + F + ')' : ''))
                  ;(c = g = 1), (d = f = 0)
                }
                ;(k = 1),
                  (e = h = i = j = l = m = 0),
                  (o = M ? -1 / M : 0),
                  (p = z.zOrigin),
                  (q = 1e-6),
                  (v = ','),
                  (w = '0'),
                  (B = D * K),
                  B && ((r = Math.cos(B)), (s = Math.sin(B)), (i = -s), (l = o * -s), (e = c * s), (h = f * s), (k = r), (o *= r), (c *= r), (f *= r)),
                  (B = C * K),
                  B &&
                    ((r = Math.cos(B)),
                    (s = Math.sin(B)),
                    (b = d * r + e * s),
                    (t = g * r + h * s),
                    (j = k * s),
                    (m = o * s),
                    (e = d * -s + e * r),
                    (h = g * -s + h * r),
                    (k *= r),
                    (o *= r),
                    (d = b),
                    (g = t)),
                  1 !== G && ((e *= G), (h *= G), (k *= G), (o *= G)),
                  1 !== F && ((d *= F), (g *= F), (j *= F), (m *= F)),
                  1 !== E && ((c *= E), (f *= E), (i *= E), (l *= E)),
                  (p || L) &&
                    (p && ((H += e * -p), (I += h * -p), (J += k * -p + p)),
                    L && ((H += z.xOrigin - (z.xOrigin * c + z.yOrigin * d) + z.xOffset), (I += z.yOrigin - (z.xOrigin * f + z.yOrigin * g) + z.yOffset)),
                    q > H && H > -q && (H = w),
                    q > I && I > -q && (I = w),
                    q > J && J > -q && (J = 0)),
                  (u = z.xPercent || z.yPercent ? 'translate(' + z.xPercent + '%,' + z.yPercent + '%) matrix3d(' : 'matrix3d('),
                  (u += (q > c && c > -q ? w : c) + v + (q > f && f > -q ? w : f) + v + (q > i && i > -q ? w : i)),
                  (u += v + (q > l && l > -q ? w : l) + v + (q > d && d > -q ? w : d) + v + (q > g && g > -q ? w : g)),
                  C || D || 1 !== G
                    ? ((u += v + (q > j && j > -q ? w : j) + v + (q > m && m > -q ? w : m) + v + (q > e && e > -q ? w : e)),
                      (u += v + (q > h && h > -q ? w : h) + v + (q > k && k > -q ? w : k) + v + (q > o && o > -q ? w : o) + v))
                    : (u += ',0,0,0,0,1,0,'),
                  (u += H + v + I + v + J + v + (M ? 1 + -J / M : 1) + ')'),
                  (A[Da] = u)
              })
        ;(j = Ha.prototype),
          (j.x = j.y = j.z = j.skewX = j.skewY = j.rotation = j.rotationX = j.rotationY = j.zOrigin = j.xPercent = j.yPercent = j.xOffset = j.yOffset = 0),
          (j.scaleX = j.scaleY = j.scaleZ = 1),
          za(
            'transform,scale,scaleX,scaleY,scaleZ,x,y,z,rotation,rotationX,rotationY,rotationZ,skewX,skewY,shortRotation,shortRotationX,shortRotationY,shortRotationZ,transformOrigin,svgOrigin,transformPerspective,directionalRotation,parseTransform,force3D,skewType,xPercent,yPercent,smoothOrigin',
            {
              parser: function (a, b, c, d, f, h, i) {
                if (d._lastParsedTransform === i) return f
                d._lastParsedTransform = i
                var j = i.scale && 'function' == typeof i.scale ? i.scale : 0
                j && (i.scale = j(r, a))
                var k,
                  l,
                  m,
                  n,
                  o,
                  p,
                  s,
                  t,
                  u,
                  v = a._gsTransform,
                  w = a.style,
                  x = 1e-6,
                  y = Ca.length,
                  z = i,
                  A = {},
                  B = 'transformOrigin',
                  C = Sa(a, e, !0, z.parseTransform),
                  D = z.transform && ('function' == typeof z.transform ? z.transform(r, q) : z.transform)
                if (
                  ((C.skewType = z.skewType || C.skewType || g.defaultSkewType),
                  (d._transform = C),
                  'rotationZ' in z && (z.rotation = z.rotationZ),
                  D && 'string' == typeof D && Da)
                )
                  (l = Q.style),
                    (l[Da] = D),
                    (l.display = 'block'),
                    (l.position = 'absolute'),
                    -1 !== D.indexOf('%') && ((l.width = aa(a, 'width')), (l.height = aa(a, 'height'))),
                    O.body.appendChild(Q),
                    (k = Sa(Q, null, !1)),
                    'simple' === C.skewType && (k.scaleY *= Math.cos(k.skewX * K)),
                    C.svg &&
                      ((p = C.xOrigin),
                      (s = C.yOrigin),
                      (k.x -= C.xOffset),
                      (k.y -= C.yOffset),
                      (z.transformOrigin || z.svgOrigin) &&
                        ((D = {}),
                        Ma(a, ia(z.transformOrigin), D, z.svgOrigin, z.smoothOrigin, !0),
                        (p = D.xOrigin),
                        (s = D.yOrigin),
                        (k.x -= D.xOffset - C.xOffset),
                        (k.y -= D.yOffset - C.yOffset)),
                      (p || s) && ((t = Ra(Q, !0)), (k.x -= p - (p * t[0] + s * t[2])), (k.y -= s - (p * t[1] + s * t[3])))),
                    O.body.removeChild(Q),
                    k.perspective || (k.perspective = C.perspective),
                    null != z.xPercent && (k.xPercent = ka(z.xPercent, C.xPercent)),
                    null != z.yPercent && (k.yPercent = ka(z.yPercent, C.yPercent))
                else if ('object' == typeof z) {
                  if (
                    ((k = {
                      scaleX: ka(null != z.scaleX ? z.scaleX : z.scale, C.scaleX),
                      scaleY: ka(null != z.scaleY ? z.scaleY : z.scale, C.scaleY),
                      scaleZ: ka(z.scaleZ, C.scaleZ),
                      x: ka(z.x, C.x),
                      y: ka(z.y, C.y),
                      z: ka(z.z, C.z),
                      xPercent: ka(z.xPercent, C.xPercent),
                      yPercent: ka(z.yPercent, C.yPercent),
                      perspective: ka(z.transformPerspective, C.perspective)
                    }),
                    (o = z.directionalRotation),
                    null != o)
                  )
                    if ('object' == typeof o) for (l in o) z[l] = o[l]
                    else z.rotation = o
                  'string' == typeof z.x && -1 !== z.x.indexOf('%') && ((k.x = 0), (k.xPercent = ka(z.x, C.xPercent))),
                    'string' == typeof z.y && -1 !== z.y.indexOf('%') && ((k.y = 0), (k.yPercent = ka(z.y, C.yPercent))),
                    (k.rotation = la('rotation' in z ? z.rotation : 'shortRotation' in z ? z.shortRotation + '_short' : C.rotation, C.rotation, 'rotation', A)),
                    Ga &&
                      ((k.rotationX = la(
                        'rotationX' in z ? z.rotationX : 'shortRotationX' in z ? z.shortRotationX + '_short' : C.rotationX || 0,
                        C.rotationX,
                        'rotationX',
                        A
                      )),
                      (k.rotationY = la(
                        'rotationY' in z ? z.rotationY : 'shortRotationY' in z ? z.shortRotationY + '_short' : C.rotationY || 0,
                        C.rotationY,
                        'rotationY',
                        A
                      ))),
                    (k.skewX = la(z.skewX, C.skewX)),
                    (k.skewY = la(z.skewY, C.skewY))
                }
                for (
                  Ga && null != z.force3D && ((C.force3D = z.force3D), (n = !0)),
                    m = C.force3D || C.z || C.rotationX || C.rotationY || k.z || k.rotationX || k.rotationY || k.perspective,
                    m || null == z.scale || (k.scaleZ = 1);
                  --y > -1;

                )
                  (u = Ca[y]),
                    (D = k[u] - C[u]),
                    (D > x || -x > D || null != z[u] || null != M[u]) &&
                      ((n = !0), (f = new ua(C, u, C[u], D, f)), u in A && (f.e = A[u]), (f.xs0 = 0), (f.plugin = h), d._overwriteProps.push(f.n))
                return (
                  (D = 'function' == typeof z.transformOrigin ? z.transformOrigin(r, q) : z.transformOrigin),
                  C.svg &&
                    (D || z.svgOrigin) &&
                    ((p = C.xOffset),
                    (s = C.yOffset),
                    Ma(a, ia(D), k, z.svgOrigin, z.smoothOrigin),
                    (f = va(C, 'xOrigin', (v ? C : k).xOrigin, k.xOrigin, f, B)),
                    (f = va(C, 'yOrigin', (v ? C : k).yOrigin, k.yOrigin, f, B)),
                    (p !== C.xOffset || s !== C.yOffset) &&
                      ((f = va(C, 'xOffset', v ? p : C.xOffset, C.xOffset, f, B)), (f = va(C, 'yOffset', v ? s : C.yOffset, C.yOffset, f, B))),
                    (D = '0px 0px')),
                  (D || (Ga && m && C.zOrigin)) &&
                    (Da
                      ? ((n = !0),
                        (u = Fa),
                        D || ((D = (aa(a, u, e, !1, '50% 50%') + '').split(' ')), (D = D[0] + ' ' + D[1] + ' ' + C.zOrigin + 'px')),
                        (D += ''),
                        (f = new ua(w, u, 0, 0, f, -1, B)),
                        (f.b = w[u]),
                        (f.plugin = h),
                        Ga
                          ? ((l = C.zOrigin),
                            (D = D.split(' ')),
                            (C.zOrigin = (D.length > 2 ? parseFloat(D[2]) : l) || 0),
                            (f.xs0 = f.e = D[0] + ' ' + (D[1] || '50%') + ' 0px'),
                            (f = new ua(C, 'zOrigin', 0, 0, f, -1, f.n)),
                            (f.b = l),
                            (f.xs0 = f.e = C.zOrigin))
                          : (f.xs0 = f.e = D))
                      : ia(D + '', C)),
                  n && (d._transformType = (C.svg && Ba) || (!m && 3 !== this._transformType) ? 2 : 3),
                  j && (i.scale = j),
                  f
                )
              },
              allowFunc: !0,
              prefix: !0
            }
          ),
          za('boxShadow', { defaultValue: '0px 0px 0px 0px #999', prefix: !0, color: !0, multi: !0, keyword: 'inset' }),
          za('clipPath', { defaultValue: 'inset(0px)', prefix: !0, multi: !0, formatter: ra('inset(0px 0px 0px 0px)', !1, !0) }),
          za('borderRadius', {
            defaultValue: '0px',
            parser: function (a, b, c, f, g, h) {
              b = this.format(b)
              var i,
                j,
                k,
                l,
                m,
                n,
                o,
                p,
                q,
                r,
                s,
                t,
                u,
                v,
                w,
                x,
                y = ['borderTopLeftRadius', 'borderTopRightRadius', 'borderBottomRightRadius', 'borderBottomLeftRadius'],
                z = a.style
              for (q = parseFloat(a.offsetWidth), r = parseFloat(a.offsetHeight), i = b.split(' '), j = 0; j < y.length; j++)
                this.p.indexOf('border') && (y[j] = Z(y[j])),
                  (m = l = aa(a, y[j], e, !1, '0px')),
                  -1 !== m.indexOf(' ') && ((l = m.split(' ')), (m = l[0]), (l = l[1])),
                  (n = k = i[j]),
                  (o = parseFloat(m)),
                  (t = m.substr((o + '').length)),
                  (u = '=' === n.charAt(1)),
                  u
                    ? ((p = parseInt(n.charAt(0) + '1', 10)), (n = n.substr(2)), (p *= parseFloat(n)), (s = n.substr((p + '').length - (0 > p ? 1 : 0)) || ''))
                    : ((p = parseFloat(n)), (s = n.substr((p + '').length))),
                  '' === s && (s = d[c] || t),
                  s !== t &&
                    ((v = ba(a, 'borderLeft', o, t)),
                    (w = ba(a, 'borderTop', o, t)),
                    '%' === s
                      ? ((m = (v / q) * 100 + '%'), (l = (w / r) * 100 + '%'))
                      : 'em' === s
                      ? ((x = ba(a, 'borderLeft', 1, 'em')), (m = v / x + 'em'), (l = w / x + 'em'))
                      : ((m = v + 'px'), (l = w + 'px')),
                    u && ((n = parseFloat(m) + p + s), (k = parseFloat(l) + p + s))),
                  (g = wa(z, y[j], m + ' ' + l, n + ' ' + k, !1, '0px', g))
              return g
            },
            prefix: !0,
            formatter: ra('0px 0px 0px 0px', !1, !0)
          }),
          za('borderBottomLeftRadius,borderBottomRightRadius,borderTopLeftRadius,borderTopRightRadius', {
            defaultValue: '0px',
            parser: function (a, b, c, d, f, g) {
              return wa(a.style, c, this.format(aa(a, c, e, !1, '0px 0px')), this.format(b), !1, '0px', f)
            },
            prefix: !0,
            formatter: ra('0px 0px', !1, !0)
          }),
          za('backgroundPosition', {
            defaultValue: '0 0',
            parser: function (a, b, c, d, f, g) {
              var h,
                i,
                j,
                k,
                l,
                m,
                n = 'background-position',
                o = e || _(a, null),
                q = this.format(
                  (o
                    ? p
                      ? o.getPropertyValue(n + '-x') + ' ' + o.getPropertyValue(n + '-y')
                      : o.getPropertyValue(n)
                    : a.currentStyle.backgroundPositionX + ' ' + a.currentStyle.backgroundPositionY) || '0 0'
                ),
                r = this.format(b)
              if ((-1 !== q.indexOf('%')) != (-1 !== r.indexOf('%')) && r.split(',').length < 2 && ((m = aa(a, 'backgroundImage').replace(D, '')), m && 'none' !== m)) {
                for (h = q.split(' '), i = r.split(' '), R.setAttribute('src', m), j = 2; --j > -1; )
                  (q = h[j]),
                    (k = -1 !== q.indexOf('%')),
                    k !== (-1 !== i[j].indexOf('%')) &&
                      ((l = 0 === j ? a.offsetWidth - R.width : a.offsetHeight - R.height),
                      (h[j] = k ? (parseFloat(q) / 100) * l + 'px' : (parseFloat(q) / l) * 100 + '%'))
                q = h.join(' ')
              }
              return this.parseComplex(a.style, q, r, f, g)
            },
            formatter: ia
          }),
          za('backgroundSize', {
            defaultValue: '0 0',
            formatter: function (a) {
              return (a += ''), 'co' === a.substr(0, 2) ? a : ia(-1 === a.indexOf(' ') ? a + ' ' + a : a)
            }
          }),
          za('perspective', { defaultValue: '0px', prefix: !0 }),
          za('perspectiveOrigin', { defaultValue: '50% 50%', prefix: !0 }),
          za('transformStyle', { prefix: !0 }),
          za('backfaceVisibility', { prefix: !0 }),
          za('userSelect', { prefix: !0 }),
          za('margin', { parser: sa('marginTop,marginRight,marginBottom,marginLeft') }),
          za('padding', { parser: sa('paddingTop,paddingRight,paddingBottom,paddingLeft') }),
          za('clip', {
            defaultValue: 'rect(0px,0px,0px,0px)',
            parser: function (a, b, c, d, f, g) {
              var h, i, j
              return (
                9 > p
                  ? ((i = a.currentStyle),
                    (j = 8 > p ? ' ' : ','),
                    (h = 'rect(' + i.clipTop + j + i.clipRight + j + i.clipBottom + j + i.clipLeft + ')'),
                    (b = this.format(b).split(',').join(j)))
                  : ((h = this.format(aa(a, this.p, e, !1, this.dflt))), (b = this.format(b))),
                this.parseComplex(a.style, h, b, f, g)
              )
            }
          }),
          za('textShadow', { defaultValue: '0px 0px 0px #999', color: !0, multi: !0 }),
          za('autoRound,strictUnits', {
            parser: function (a, b, c, d, e) {
              return e
            }
          }),
          za('border', {
            defaultValue: '0px solid #000',
            parser: function (a, b, c, d, f, g) {
              var h = aa(a, 'borderTopWidth', e, !1, '0px'),
                i = this.format(b).split(' '),
                j = i[0].replace(w, '')
              return (
                'px' !== j && (h = parseFloat(h) / ba(a, 'borderTopWidth', 1, j) + j),
                this.parseComplex(
                  a.style,
                  this.format(h + ' ' + aa(a, 'borderTopStyle', e, !1, 'solid') + ' ' + aa(a, 'borderTopColor', e, !1, '#000')),
                  i.join(' '),
                  f,
                  g
                )
              )
            },
            color: !0,
            formatter: function (a) {
              var b = a.split(' ')
              return b[0] + ' ' + (b[1] || 'solid') + ' ' + (a.match(qa) || ['#000'])[0]
            }
          }),
          za('borderWidth', { parser: sa('borderTopWidth,borderRightWidth,borderBottomWidth,borderLeftWidth') }),
          za('float,cssFloat,styleFloat', {
            parser: function (a, b, c, d, e, f) {
              var g = a.style,
                h = 'cssFloat' in g ? 'cssFloat' : 'styleFloat'
              return new ua(g, h, 0, 0, e, -1, c, !1, 0, g[h], b)
            }
          })
        var Va = function (a) {
          var b,
            c = this.t,
            d = c.filter || aa(this.data, 'filter') || '',
            e = (this.s + this.c * a) | 0
          100 === e &&
            (-1 === d.indexOf('atrix(') && -1 === d.indexOf('radient(') && -1 === d.indexOf('oader(')
              ? (c.removeAttribute('filter'), (b = !aa(this.data, 'filter')))
              : ((c.filter = d.replace(z, '')), (b = !0))),
            b ||
              (this.xn1 && (c.filter = d = d || 'alpha(opacity=' + e + ')'),
              -1 === d.indexOf('pacity') ? (0 === e && this.xn1) || (c.filter = d + ' alpha(opacity=' + e + ')') : (c.filter = d.replace(x, 'opacity=' + e)))
        }
        za('opacity,alpha,autoAlpha', {
          defaultValue: '1',
          parser: function (a, b, c, d, f, g) {
            var h = parseFloat(aa(a, 'opacity', e, !1, '1')),
              i = a.style,
              j = 'autoAlpha' === c
            return (
              'string' == typeof b && '=' === b.charAt(1) && (b = ('-' === b.charAt(0) ? -1 : 1) * parseFloat(b.substr(2)) + h),
              j && 1 === h && 'hidden' === aa(a, 'visibility', e) && 0 !== b && (h = 0),
              U
                ? (f = new ua(i, 'opacity', h, b - h, f))
                : ((f = new ua(i, 'opacity', 100 * h, 100 * (b - h), f)),
                  (f.xn1 = j ? 1 : 0),
                  (i.zoom = 1),
                  (f.type = 2),
                  (f.b = 'alpha(opacity=' + f.s + ')'),
                  (f.e = 'alpha(opacity=' + (f.s + f.c) + ')'),
                  (f.data = a),
                  (f.plugin = g),
                  (f.setRatio = Va)),
              j &&
                ((f = new ua(i, 'visibility', 0, 0, f, -1, null, !1, 0, 0 !== h ? 'inherit' : 'hidden', 0 === b ? 'hidden' : 'inherit')),
                (f.xs0 = 'inherit'),
                d._overwriteProps.push(f.n),
                d._overwriteProps.push(c)),
              f
            )
          }
        })
        var Wa = function (a, b) {
            b &&
              (a.removeProperty
                ? (('ms' === b.substr(0, 2) || 'webkit' === b.substr(0, 6)) && (b = '-' + b), a.removeProperty(b.replace(B, '-$1').toLowerCase()))
                : a.removeAttribute(b))
          },
          Xa = function (a) {
            if (((this.t._gsClassPT = this), 1 === a || 0 === a)) {
              this.t.setAttribute('class', 0 === a ? this.b : this.e)
              for (var b = this.data, c = this.t.style; b; ) b.v ? (c[b.p] = b.v) : Wa(c, b.p), (b = b._next)
              1 === a && this.t._gsClassPT === this && (this.t._gsClassPT = null)
            } else this.t.getAttribute('class') !== this.e && this.t.setAttribute('class', this.e)
          }
        za('className', {
          parser: function (a, b, d, f, g, h, i) {
            var j,
              k,
              l,
              m,
              n,
              o = a.getAttribute('class') || '',
              p = a.style.cssText
            if (((g = f._classNamePT = new ua(a, d, 0, 0, g, 2)), (g.setRatio = Xa), (g.pr = -11), (c = !0), (g.b = o), (k = da(a, e)), (l = a._gsClassPT))) {
              for (m = {}, n = l.data; n; ) (m[n.p] = 1), (n = n._next)
              l.setRatio(1)
            }
            return (
              (a._gsClassPT = g),
              (g.e = '=' !== b.charAt(1) ? b : o.replace(new RegExp('(?:\\s|^)' + b.substr(2) + '(?![\\w-])'), '') + ('+' === b.charAt(0) ? ' ' + b.substr(2) : '')),
              a.setAttribute('class', g.e),
              (j = ea(a, k, da(a), i, m)),
              a.setAttribute('class', o),
              (g.data = j.firstMPT),
              (a.style.cssText = p),
              (g = g.xfirst = f.parse(a, j.difs, g, h))
            )
          }
        })
        var Ya = function (a) {
          if ((1 === a || 0 === a) && this.data._totalTime === this.data._totalDuration && 'isFromStart' !== this.data.data) {
            var b,
              c,
              d,
              e,
              f,
              g = this.t.style,
              h = i.transform.parse
            if ('all' === this.e) (g.cssText = ''), (e = !0)
            else
              for (b = this.e.split(' ').join('').split(','), d = b.length; --d > -1; )
                (c = b[d]), i[c] && (i[c].parse === h ? (e = !0) : (c = 'transformOrigin' === c ? Fa : i[c].p)), Wa(g, c)
            e &&
              (Wa(g, Da),
              (f = this.t._gsTransform),
              f && (f.svg && (this.t.removeAttribute('data-svg-origin'), this.t.removeAttribute('transform')), delete this.t._gsTransform))
          }
        }
        for (
          za('clearProps', {
            parser: function (a, b, d, e, f) {
              return (f = new ua(a, d, 0, 0, f, 2)), (f.setRatio = Ya), (f.e = b), (f.pr = -10), (f.data = e._tween), (c = !0), f
            }
          }),
            j = 'bezier,throwProps,physicsProps,physics2D'.split(','),
            xa = j.length;
          xa--;

        )
          Aa(j[xa])
        ;(j = g.prototype),
          (j._firstPT = j._lastParsedTransform = j._transform = null),
          (j._onInitTween = function (a, b, h, j) {
            if (!a.nodeType) return !1
            ;(this._target = q = a),
              (this._tween = h),
              (this._vars = b),
              (r = j),
              (k = b.autoRound),
              (c = !1),
              (d = b.suffixMap || g.suffixMap),
              (e = _(a, '')),
              (f = this._overwriteProps)
            var n,
              p,
              s,
              t,
              u,
              v,
              w,
              x,
              z,
              A = a.style
            if (
              (l && '' === A.zIndex && ((n = aa(a, 'zIndex', e)), ('auto' === n || '' === n) && this._addLazySet(A, 'zIndex', 0)),
              'string' == typeof b &&
                ((t = A.cssText),
                (n = da(a, e)),
                (A.cssText = t + ';' + b),
                (n = ea(a, n, da(a)).difs),
                !U && y.test(b) && (n.opacity = parseFloat(RegExp.$1)),
                (b = n),
                (A.cssText = t)),
              b.className ? (this._firstPT = p = i.className.parse(a, b.className, 'className', this, null, null, b)) : (this._firstPT = p = this.parse(a, b, null)),
              this._transformType)
            ) {
              for (
                z = 3 === this._transformType,
                  Da
                    ? m &&
                      ((l = !0),
                      '' === A.zIndex && ((w = aa(a, 'zIndex', e)), ('auto' === w || '' === w) && this._addLazySet(A, 'zIndex', 0)),
                      o && this._addLazySet(A, 'WebkitBackfaceVisibility', this._vars.WebkitBackfaceVisibility || (z ? 'visible' : 'hidden')))
                    : (A.zoom = 1),
                  s = p;
                s && s._next;

              )
                s = s._next
              ;(x = new ua(a, 'transform', 0, 0, null, 2)),
                this._linkCSSP(x, null, s),
                (x.setRatio = Da ? Ua : Ta),
                (x.data = this._transform || Sa(a, e, !0)),
                (x.tween = h),
                (x.pr = -1),
                f.pop()
            }
            if (c) {
              for (; p; ) {
                for (v = p._next, s = t; s && s.pr > p.pr; ) s = s._next
                ;(p._prev = s ? s._prev : u) ? (p._prev._next = p) : (t = p), (p._next = s) ? (s._prev = p) : (u = p), (p = v)
              }
              this._firstPT = t
            }
            return !0
          }),
          (j.parse = function (a, b, c, f) {
            var g,
              h,
              j,
              l,
              m,
              n,
              o,
              p,
              s,
              t,
              u = a.style
            for (g in b) {
              if (((n = b[g]), (h = i[g]), 'function' != typeof n || (h && h.allowFunc) || (n = n(r, q)), h)) c = h.parse(a, n, g, this, c, f, b)
              else {
                if ('--' === g.substr(0, 2)) {
                  this._tween._propLookup[g] = this._addTween.call(this._tween, a.style, 'setProperty', _(a).getPropertyValue(g) + '', n + '', g, !1, g)
                  continue
                }
                ;(m = aa(a, g, e) + ''),
                  (s = 'string' == typeof n),
                  'color' === g || 'fill' === g || 'stroke' === g || -1 !== g.indexOf('Color') || (s && A.test(n))
                    ? (s || ((n = oa(n)), (n = (n.length > 3 ? 'rgba(' : 'rgb(') + n.join(',') + ')')), (c = wa(u, g, m, n, !0, 'transparent', c, 0, f)))
                    : s && J.test(n)
                    ? (c = wa(u, g, m, n, !0, null, c, 0, f))
                    : ((j = parseFloat(m)),
                      (o = j || 0 === j ? m.substr((j + '').length) : ''),
                      ('' === m || 'auto' === m) &&
                        ('width' === g || 'height' === g
                          ? ((j = ha(a, g, e)), (o = 'px'))
                          : 'left' === g || 'top' === g
                          ? ((j = ca(a, g, e)), (o = 'px'))
                          : ((j = 'opacity' !== g ? 0 : 1), (o = ''))),
                      (t = s && '=' === n.charAt(1)),
                      t
                        ? ((l = parseInt(n.charAt(0) + '1', 10)), (n = n.substr(2)), (l *= parseFloat(n)), (p = n.replace(w, '')))
                        : ((l = parseFloat(n)), (p = s ? n.replace(w, '') : '')),
                      '' === p && (p = g in d ? d[g] : o),
                      (n = l || 0 === l ? (t ? l + j : l) + p : b[g]),
                      o !== p &&
                        ('' !== p || 'lineHeight' === g) &&
                        (l || 0 === l) &&
                        j &&
                        ((j = ba(a, g, j, o)),
                        '%' === p
                          ? ((j /= ba(a, g, 100, '%') / 100), b.strictUnits !== !0 && (m = j + '%'))
                          : 'em' === p || 'rem' === p || 'vw' === p || 'vh' === p
                          ? (j /= ba(a, g, 1, p))
                          : 'px' !== p && ((l = ba(a, g, l, p)), (p = 'px')),
                        t && (l || 0 === l) && (n = l + j + p)),
                      t && (l += j),
                      (!j && 0 !== j) || (!l && 0 !== l)
                        ? void 0 !== u[g] && (n || (n + '' != 'NaN' && null != n))
                          ? ((c = new ua(u, g, l || j || 0, 0, c, -1, g, !1, 0, m, n)), (c.xs0 = 'none' !== n || ('display' !== g && -1 === g.indexOf('Style')) ? n : m))
                          : W('invalid ' + g + ' tween value: ' + b[g])
                        : ((c = new ua(u, g, j, l - j, c, 0, g, k !== !1 && ('px' === p || 'zIndex' === g), 0, m, n)), (c.xs0 = p)))
              }
              f && c && !c.plugin && (c.plugin = f)
            }
            return c
          }),
          (j.setRatio = function (a) {
            var b,
              c,
              d,
              e = this._firstPT,
              f = 1e-6
            if (1 !== a || (this._tween._time !== this._tween._duration && 0 !== this._tween._time))
              if (a || (this._tween._time !== this._tween._duration && 0 !== this._tween._time) || this._tween._rawPrevTime === -1e-6)
                for (; e; ) {
                  if (((b = e.c * a + e.s), e.r ? (b = e.r(b)) : f > b && b > -f && (b = 0), e.type))
                    if (1 === e.type)
                      if (((d = e.l), 2 === d)) e.t[e.p] = e.xs0 + b + e.xs1 + e.xn1 + e.xs2
                      else if (3 === d) e.t[e.p] = e.xs0 + b + e.xs1 + e.xn1 + e.xs2 + e.xn2 + e.xs3
                      else if (4 === d) e.t[e.p] = e.xs0 + b + e.xs1 + e.xn1 + e.xs2 + e.xn2 + e.xs3 + e.xn3 + e.xs4
                      else if (5 === d) e.t[e.p] = e.xs0 + b + e.xs1 + e.xn1 + e.xs2 + e.xn2 + e.xs3 + e.xn3 + e.xs4 + e.xn4 + e.xs5
                      else {
                        for (c = e.xs0 + b + e.xs1, d = 1; d < e.l; d++) c += e['xn' + d] + e['xs' + (d + 1)]
                        e.t[e.p] = c
                      }
                    else -1 === e.type ? (e.t[e.p] = e.xs0) : e.setRatio && e.setRatio(a)
                  else e.t[e.p] = b + e.xs0
                  e = e._next
                }
              else for (; e; ) 2 !== e.type ? (e.t[e.p] = e.b) : e.setRatio(a), (e = e._next)
            else
              for (; e; ) {
                if (2 !== e.type)
                  if (e.r && -1 !== e.type)
                    if (((b = e.r(e.s + e.c)), e.type)) {
                      if (1 === e.type) {
                        for (d = e.l, c = e.xs0 + b + e.xs1, d = 1; d < e.l; d++) c += e['xn' + d] + e['xs' + (d + 1)]
                        e.t[e.p] = c
                      }
                    } else e.t[e.p] = b + e.xs0
                  else e.t[e.p] = e.e
                else e.setRatio(a)
                e = e._next
              }
          }),
          (j._enableTransforms = function (a) {
            ;(this._transform = this._transform || Sa(this._target, e, !0)),
              (this._transformType = (this._transform.svg && Ba) || (!a && 3 !== this._transformType) ? 2 : 3)
          })
        var Za = function (a) {
          ;(this.t[this.p] = this.e), this.data._linkCSSP(this, this._next, null, !0)
        }
        ;(j._addLazySet = function (a, b, c) {
          var d = (this._firstPT = new ua(a, b, 0, 0, this._firstPT, 2))
          ;(d.e = c), (d.setRatio = Za), (d.data = this)
        }),
          (j._linkCSSP = function (a, b, c, d) {
            return (
              a &&
                (b && (b._prev = a),
                a._next && (a._next._prev = a._prev),
                a._prev ? (a._prev._next = a._next) : this._firstPT === a && ((this._firstPT = a._next), (d = !0)),
                c ? (c._next = a) : d || null !== this._firstPT || (this._firstPT = a),
                (a._next = b),
                (a._prev = c)),
              a
            )
          }),
          (j._mod = function (a) {
            for (var b = this._firstPT; b; ) 'function' == typeof a[b.p] && (b.r = a[b.p]), (b = b._next)
          }),
          (j._kill = function (b) {
            var c,
              d,
              e,
              f = b
            if (b.autoAlpha || b.alpha) {
              f = {}
              for (d in b) f[d] = b[d]
              ;(f.opacity = 1), f.autoAlpha && (f.visibility = 1)
            }
            for (
              b.className &&
                (c = this._classNamePT) &&
                ((e = c.xfirst),
                e && e._prev ? this._linkCSSP(e._prev, c._next, e._prev._prev) : e === this._firstPT && (this._firstPT = c._next),
                c._next && this._linkCSSP(c._next, c._next._next, e._prev),
                (this._classNamePT = null)),
                c = this._firstPT;
              c;

            )
              c.plugin && c.plugin !== d && c.plugin._kill && (c.plugin._kill(b), (d = c.plugin)), (c = c._next)
            return a.prototype._kill.call(this, f)
          })
        var $a = function (a, b, c) {
          var d, e, f, g
          if (a.slice) for (e = a.length; --e > -1; ) $a(a[e], b, c)
          else
            for (d = a.childNodes, e = d.length; --e > -1; )
              (f = d[e]), (g = f.type), f.style && (b.push(da(f)), c && c.push(f)), (1 !== g && 9 !== g && 11 !== g) || !f.childNodes.length || $a(f, b, c)
        }
        return (
          (g.cascadeTo = function (a, c, d) {
            var e,
              f,
              g,
              h,
              i = b.to(a, c, d),
              j = [i],
              k = [],
              l = [],
              m = [],
              n = b._internals.reservedProps
            for (a = i._targets || i.target, $a(a, k, m), i.render(c, !0, !0), $a(a, l), i.render(0, !0, !0), i._enabled(!0), e = m.length; --e > -1; )
              if (((f = ea(m[e], k[e], l[e])), f.firstMPT)) {
                f = f.difs
                for (g in d) n[g] && (f[g] = d[g])
                h = {}
                for (g in f) h[g] = k[e][g]
                j.push(b.fromTo(m[e], c, h, f))
              }
            return j
          }),
          a.activate([g]),
          g
        )
      },
      !0
    ),
    (function () {
      var a = _gsScope._gsDefine.plugin({
          propName: 'roundProps',
          version: '1.7.0',
          priority: -1,
          API: 2,
          init: function (a, b, c) {
            return (this._tween = c), !0
          }
        }),
        b = function (a) {
          var b = 1 > a ? Math.pow(10, (a + '').length - 2) : 1
          return function (c) {
            return ((Math.round(c / a) * a * b) | 0) / b
          }
        },
        c = function (a, b) {
          for (; a; ) a.f || a.blob || (a.m = b || Math.round), (a = a._next)
        },
        d = a.prototype
      ;(d._onInitAllProps = function () {
        var a,
          d,
          e,
          f,
          g = this._tween,
          h = g.vars.roundProps,
          i = {},
          j = g._propLookup.roundProps
        if ('object' != typeof h || h.push) for ('string' == typeof h && (h = h.split(',')), e = h.length; --e > -1; ) i[h[e]] = Math.round
        else for (f in h) i[f] = b(h[f])
        for (f in i)
          for (a = g._firstPT; a; )
            (d = a._next),
              a.pg
                ? a.t._mod(i)
                : a.n === f &&
                  (2 === a.f && a.t
                    ? c(a.t._firstPT, i[f])
                    : (this._add(a.t, f, a.s, a.c, i[f]),
                      d && (d._prev = a._prev),
                      a._prev ? (a._prev._next = d) : g._firstPT === a && (g._firstPT = d),
                      (a._next = a._prev = null),
                      (g._propLookup[f] = j))),
              (a = d)
        return !1
      }),
        (d._add = function (a, b, c, d, e) {
          this._addTween(a, b, c, c + d, b, e || Math.round), this._overwriteProps.push(b)
        })
    })(),
    (function () {
      _gsScope._gsDefine.plugin({
        propName: 'attr',
        API: 2,
        version: '0.6.1',
        init: function (a, b, c, d) {
          var e, f
          if ('function' != typeof a.setAttribute) return !1
          for (e in b)
            (f = b[e]), 'function' == typeof f && (f = f(d, a)), this._addTween(a, 'setAttribute', a.getAttribute(e) + '', f + '', e, !1, e), this._overwriteProps.push(e)
          return !0
        }
      })
    })(),
    (_gsScope._gsDefine.plugin({
      propName: 'directionalRotation',
      version: '0.3.1',
      API: 2,
      init: function (a, b, c, d) {
        'object' != typeof b && (b = { rotation: b }), (this.finals = {})
        var e,
          f,
          g,
          h,
          i,
          j,
          k = b.useRadians === !0 ? 2 * Math.PI : 360,
          l = 1e-6
        for (e in b)
          'useRadians' !== e &&
            ((h = b[e]),
            'function' == typeof h && (h = h(d, a)),
            (j = (h + '').split('_')),
            (f = j[0]),
            (g = parseFloat('function' != typeof a[e] ? a[e] : a[e.indexOf('set') || 'function' != typeof a['get' + e.substr(3)] ? e : 'get' + e.substr(3)]())),
            (h = this.finals[e] = 'string' == typeof f && '=' === f.charAt(1) ? g + parseInt(f.charAt(0) + '1', 10) * Number(f.substr(2)) : Number(f) || 0),
            (i = h - g),
            j.length &&
              ((f = j.join('_')),
              -1 !== f.indexOf('short') && ((i %= k), i !== i % (k / 2) && (i = 0 > i ? i + k : i - k)),
              -1 !== f.indexOf('_cw') && 0 > i
                ? (i = ((i + 9999999999 * k) % k) - ((i / k) | 0) * k)
                : -1 !== f.indexOf('ccw') && i > 0 && (i = ((i - 9999999999 * k) % k) - ((i / k) | 0) * k)),
            (i > l || -l > i) && (this._addTween(a, e, g, g + i, e), this._overwriteProps.push(e)))
        return !0
      },
      set: function (a) {
        var b
        if (1 !== a) this._super.setRatio.call(this, a)
        else for (b = this._firstPT; b; ) b.f ? b.t[b.p](this.finals[b.p]) : (b.t[b.p] = this.finals[b.p]), (b = b._next)
      }
    })._autoCSS = !0),
    _gsScope._gsDefine(
      'easing.Back',
      ['easing.Ease'],
      function (a) {
        var b,
          c,
          d,
          e,
          f = _gsScope.GreenSockGlobals || _gsScope,
          g = f.com.greensock,
          h = 2 * Math.PI,
          i = Math.PI / 2,
          j = g._class,
          k = function (b, c) {
            var d = j('easing.' + b, function () {}, !0),
              e = (d.prototype = new a())
            return (e.constructor = d), (e.getRatio = c), d
          },
          l = a.register || function () {},
          m = function (a, b, c, d, e) {
            var f = j('easing.' + a, { easeOut: new b(), easeIn: new c(), easeInOut: new d() }, !0)
            return l(f, a), f
          },
          n = function (a, b, c) {
            ;(this.t = a), (this.v = b), c && ((this.next = c), (c.prev = this), (this.c = c.v - b), (this.gap = c.t - a))
          },
          o = function (b, c) {
            var d = j(
                'easing.' + b,
                function (a) {
                  ;(this._p1 = a || 0 === a ? a : 1.70158), (this._p2 = 1.525 * this._p1)
                },
                !0
              ),
              e = (d.prototype = new a())
            return (
              (e.constructor = d),
              (e.getRatio = c),
              (e.config = function (a) {
                return new d(a)
              }),
              d
            )
          },
          p = m(
            'Back',
            o('BackOut', function (a) {
              return (a -= 1) * a * ((this._p1 + 1) * a + this._p1) + 1
            }),
            o('BackIn', function (a) {
              return a * a * ((this._p1 + 1) * a - this._p1)
            }),
            o('BackInOut', function (a) {
              return (a *= 2) < 1 ? 0.5 * a * a * ((this._p2 + 1) * a - this._p2) : 0.5 * ((a -= 2) * a * ((this._p2 + 1) * a + this._p2) + 2)
            })
          ),
          q = j(
            'easing.SlowMo',
            function (a, b, c) {
              ;(b = b || 0 === b ? b : 0.7),
                null == a ? (a = 0.7) : a > 1 && (a = 1),
                (this._p = 1 !== a ? b : 0),
                (this._p1 = (1 - a) / 2),
                (this._p2 = a),
                (this._p3 = this._p1 + this._p2),
                (this._calcEnd = c === !0)
            },
            !0
          ),
          r = (q.prototype = new a())
        return (
          (r.constructor = q),
          (r.getRatio = function (a) {
            var b = a + (0.5 - a) * this._p
            return a < this._p1
              ? this._calcEnd
                ? 1 - (a = 1 - a / this._p1) * a
                : b - (a = 1 - a / this._p1) * a * a * a * b
              : a > this._p3
              ? this._calcEnd
                ? 1 === a
                  ? 0
                  : 1 - (a = (a - this._p3) / this._p1) * a
                : b + (a - b) * (a = (a - this._p3) / this._p1) * a * a * a
              : this._calcEnd
              ? 1
              : b
          }),
          (q.ease = new q(0.7, 0.7)),
          (r.config = q.config =
            function (a, b, c) {
              return new q(a, b, c)
            }),
          (b = j(
            'easing.SteppedEase',
            function (a, b) {
              ;(a = a || 1), (this._p1 = 1 / a), (this._p2 = a + (b ? 0 : 1)), (this._p3 = b ? 1 : 0)
            },
            !0
          )),
          (r = b.prototype = new a()),
          (r.constructor = b),
          (r.getRatio = function (a) {
            return 0 > a ? (a = 0) : a >= 1 && (a = 0.999999999), (((this._p2 * a) | 0) + this._p3) * this._p1
          }),
          (r.config = b.config =
            function (a, c) {
              return new b(a, c)
            }),
          (c = j(
            'easing.ExpoScaleEase',
            function (a, b, c) {
              ;(this._p1 = Math.log(b / a)), (this._p2 = b - a), (this._p3 = a), (this._ease = c)
            },
            !0
          )),
          (r = c.prototype = new a()),
          (r.constructor = c),
          (r.getRatio = function (a) {
            return this._ease && (a = this._ease.getRatio(a)), (this._p3 * Math.exp(this._p1 * a) - this._p3) / this._p2
          }),
          (r.config = c.config =
            function (a, b, d) {
              return new c(a, b, d)
            }),
          (d = j(
            'easing.RoughEase',
            function (b) {
              b = b || {}
              for (
                var c,
                  d,
                  e,
                  f,
                  g,
                  h,
                  i = b.taper || 'none',
                  j = [],
                  k = 0,
                  l = 0 | (b.points || 20),
                  m = l,
                  o = b.randomize !== !1,
                  p = b.clamp === !0,
                  q = b.template instanceof a ? b.template : null,
                  r = 'number' == typeof b.strength ? 0.4 * b.strength : 0.4;
                --m > -1;

              )
                (c = o ? Math.random() : (1 / l) * m),
                  (d = q ? q.getRatio(c) : c),
                  'none' === i
                    ? (e = r)
                    : 'out' === i
                    ? ((f = 1 - c), (e = f * f * r))
                    : 'in' === i
                    ? (e = c * c * r)
                    : 0.5 > c
                    ? ((f = 2 * c), (e = f * f * 0.5 * r))
                    : ((f = 2 * (1 - c)), (e = f * f * 0.5 * r)),
                  o ? (d += Math.random() * e - 0.5 * e) : m % 2 ? (d += 0.5 * e) : (d -= 0.5 * e),
                  p && (d > 1 ? (d = 1) : 0 > d && (d = 0)),
                  (j[k++] = { x: c, y: d })
              for (
                j.sort(function (a, b) {
                  return a.x - b.x
                }),
                  h = new n(1, 1, null),
                  m = l;
                --m > -1;

              )
                (g = j[m]), (h = new n(g.x, g.y, h))
              this._prev = new n(0, 0, 0 !== h.t ? h : h.next)
            },
            !0
          )),
          (r = d.prototype = new a()),
          (r.constructor = d),
          (r.getRatio = function (a) {
            var b = this._prev
            if (a > b.t) {
              for (; b.next && a >= b.t; ) b = b.next
              b = b.prev
            } else for (; b.prev && a <= b.t; ) b = b.prev
            return (this._prev = b), b.v + ((a - b.t) / b.gap) * b.c
          }),
          (r.config = function (a) {
            return new d(a)
          }),
          (d.ease = new d()),
          m(
            'Bounce',
            k('BounceOut', function (a) {
              return 1 / 2.75 > a
                ? 7.5625 * a * a
                : 2 / 2.75 > a
                ? 7.5625 * (a -= 1.5 / 2.75) * a + 0.75
                : 2.5 / 2.75 > a
                ? 7.5625 * (a -= 2.25 / 2.75) * a + 0.9375
                : 7.5625 * (a -= 2.625 / 2.75) * a + 0.984375
            }),
            k('BounceIn', function (a) {
              return (a = 1 - a) < 1 / 2.75
                ? 1 - 7.5625 * a * a
                : 2 / 2.75 > a
                ? 1 - (7.5625 * (a -= 1.5 / 2.75) * a + 0.75)
                : 2.5 / 2.75 > a
                ? 1 - (7.5625 * (a -= 2.25 / 2.75) * a + 0.9375)
                : 1 - (7.5625 * (a -= 2.625 / 2.75) * a + 0.984375)
            }),
            k('BounceInOut', function (a) {
              var b = 0.5 > a
              return (
                (a = b ? 1 - 2 * a : 2 * a - 1),
                (a =
                  1 / 2.75 > a
                    ? 7.5625 * a * a
                    : 2 / 2.75 > a
                    ? 7.5625 * (a -= 1.5 / 2.75) * a + 0.75
                    : 2.5 / 2.75 > a
                    ? 7.5625 * (a -= 2.25 / 2.75) * a + 0.9375
                    : 7.5625 * (a -= 2.625 / 2.75) * a + 0.984375),
                b ? 0.5 * (1 - a) : 0.5 * a + 0.5
              )
            })
          ),
          m(
            'Circ',
            k('CircOut', function (a) {
              return Math.sqrt(1 - (a -= 1) * a)
            }),
            k('CircIn', function (a) {
              return -(Math.sqrt(1 - a * a) - 1)
            }),
            k('CircInOut', function (a) {
              return (a *= 2) < 1 ? -0.5 * (Math.sqrt(1 - a * a) - 1) : 0.5 * (Math.sqrt(1 - (a -= 2) * a) + 1)
            })
          ),
          (e = function (b, c, d) {
            var e = j(
                'easing.' + b,
                function (a, b) {
                  ;(this._p1 = a >= 1 ? a : 1),
                    (this._p2 = (b || d) / (1 > a ? a : 1)),
                    (this._p3 = (this._p2 / h) * (Math.asin(1 / this._p1) || 0)),
                    (this._p2 = h / this._p2)
                },
                !0
              ),
              f = (e.prototype = new a())
            return (
              (f.constructor = e),
              (f.getRatio = c),
              (f.config = function (a, b) {
                return new e(a, b)
              }),
              e
            )
          }),
          m(
            'Elastic',
            e(
              'ElasticOut',
              function (a) {
                return this._p1 * Math.pow(2, -10 * a) * Math.sin((a - this._p3) * this._p2) + 1
              },
              0.3
            ),
            e(
              'ElasticIn',
              function (a) {
                return -(this._p1 * Math.pow(2, 10 * (a -= 1)) * Math.sin((a - this._p3) * this._p2))
              },
              0.3
            ),
            e(
              'ElasticInOut',
              function (a) {
                return (a *= 2) < 1
                  ? -0.5 * (this._p1 * Math.pow(2, 10 * (a -= 1)) * Math.sin((a - this._p3) * this._p2))
                  : this._p1 * Math.pow(2, -10 * (a -= 1)) * Math.sin((a - this._p3) * this._p2) * 0.5 + 1
              },
              0.45
            )
          ),
          m(
            'Expo',
            k('ExpoOut', function (a) {
              return 1 - Math.pow(2, -10 * a)
            }),
            k('ExpoIn', function (a) {
              return Math.pow(2, 10 * (a - 1)) - 0.001
            }),
            k('ExpoInOut', function (a) {
              return (a *= 2) < 1 ? 0.5 * Math.pow(2, 10 * (a - 1)) : 0.5 * (2 - Math.pow(2, -10 * (a - 1)))
            })
          ),
          m(
            'Sine',
            k('SineOut', function (a) {
              return Math.sin(a * i)
            }),
            k('SineIn', function (a) {
              return -Math.cos(a * i) + 1
            }),
            k('SineInOut', function (a) {
              return -0.5 * (Math.cos(Math.PI * a) - 1)
            })
          ),
          j(
            'easing.EaseLookup',
            {
              find: function (b) {
                return a.map[b]
              }
            },
            !0
          ),
          l(f.SlowMo, 'SlowMo', 'ease,'),
          l(d, 'RoughEase', 'ease,'),
          l(b, 'SteppedEase', 'ease,'),
          p
        )
      },
      !0
    )
}),
  _gsScope._gsDefine && _gsScope._gsQueue.pop()(),
  (function (a, b) {
    'use strict'
    var c = {},
      d = a.document,
      e = (a.GreenSockGlobals = a.GreenSockGlobals || a),
      f = e[b]
    if (f) return 'undefined' != typeof module && module.exports && (module.exports = f), f
    var g,
      h,
      i,
      j,
      k,
      l = function (a) {
        var b,
          c = a.split('.'),
          d = e
        for (b = 0; b < c.length; b++) d[c[b]] = d = d[c[b]] || {}
        return d
      },
      m = l('com.greensock'),
      n = 1e-8,
      o = function (a) {
        var b,
          c = [],
          d = a.length
        for (b = 0; b !== d; c.push(a[b++]));
        return c
      },
      p = function () {},
      q = (function () {
        var a = Object.prototype.toString,
          b = a.call([])
        return function (c) {
          return null != c && (c instanceof Array || ('object' == typeof c && !!c.push && a.call(c) === b))
        }
      })(),
      r = {},
      s = function (d, f, g, h) {
        ;(this.sc = r[d] ? r[d].sc : []), (r[d] = this), (this.gsClass = null), (this.func = g)
        var i = []
        ;(this.check = function (j) {
          for (var k, m, n, o, p = f.length, q = p; --p > -1; ) (k = r[f[p]] || new s(f[p], [])).gsClass ? ((i[p] = k.gsClass), q--) : j && k.sc.push(this)
          if (0 === q && g) {
            if (((m = ('com.greensock.' + d).split('.')), (n = m.pop()), (o = l(m.join('.'))[n] = this.gsClass = g.apply(g, i)), h))
              if (((e[n] = c[n] = o), 'undefined' != typeof module && module.exports))
                if (d === b) {
                  module.exports = c[b] = o
                  for (p in c) o[p] = c[p]
                } else c[b] && (c[b][n] = o)
              else
                'function' == typeof define &&
                  define.amd &&
                  define((a.GreenSockAMDPath ? a.GreenSockAMDPath + '/' : '') + d.split('.').pop(), [], function () {
                    return o
                  })
            for (p = 0; p < this.sc.length; p++) this.sc[p].check()
          }
        }),
          this.check(!0)
      },
      t = (a._gsDefine = function (a, b, c, d) {
        return new s(a, b, c, d)
      }),
      u = (m._class = function (a, b, c) {
        return (
          (b = b || function () {}),
          t(
            a,
            [],
            function () {
              return b
            },
            c
          ),
          b
        )
      })
    t.globals = e
    var v = [0, 0, 1, 1],
      w = u(
        'easing.Ease',
        function (a, b, c, d) {
          ;(this._func = a), (this._type = c || 0), (this._power = d || 0), (this._params = b ? v.concat(b) : v)
        },
        !0
      ),
      x = (w.map = {}),
      y = (w.register = function (a, b, c, d) {
        for (var e, f, g, h, i = b.split(','), j = i.length, k = (c || 'easeIn,easeOut,easeInOut').split(','); --j > -1; )
          for (f = i[j], e = d ? u('easing.' + f, null, !0) : m.easing[f] || {}, g = k.length; --g > -1; )
            (h = k[g]), (x[f + '.' + h] = x[h + f] = e[h] = a.getRatio ? a : a[h] || new a())
      })
    for (
      i = w.prototype,
        i._calcEnd = !1,
        i.getRatio = function (a) {
          if (this._func) return (this._params[0] = a), this._func.apply(null, this._params)
          var b = this._type,
            c = this._power,
            d = 1 === b ? 1 - a : 2 === b ? a : 0.5 > a ? 2 * a : 2 * (1 - a)
          return (
            1 === c ? (d *= d) : 2 === c ? (d *= d * d) : 3 === c ? (d *= d * d * d) : 4 === c && (d *= d * d * d * d),
            1 === b ? 1 - d : 2 === b ? d : 0.5 > a ? d / 2 : 1 - d / 2
          )
        },
        g = ['Linear', 'Quad', 'Cubic', 'Quart', 'Quint,Strong'],
        h = g.length;
      --h > -1;

    )
      (i = g[h] + ',Power' + h),
        y(new w(null, null, 1, h), i, 'easeOut', !0),
        y(new w(null, null, 2, h), i, 'easeIn' + (0 === h ? ',easeNone' : '')),
        y(new w(null, null, 3, h), i, 'easeInOut')
    ;(x.linear = m.easing.Linear.easeIn), (x.swing = m.easing.Quad.easeInOut)
    var z = u('events.EventDispatcher', function (a) {
      ;(this._listeners = {}), (this._eventTarget = a || this)
    })
    ;(i = z.prototype),
      (i.addEventListener = function (a, b, c, d, e) {
        e = e || 0
        var f,
          g,
          h = this._listeners[a],
          i = 0
        for (this !== j || k || j.wake(), null == h && (this._listeners[a] = h = []), g = h.length; --g > -1; )
          (f = h[g]), f.c === b && f.s === c ? h.splice(g, 1) : 0 === i && f.pr < e && (i = g + 1)
        h.splice(i, 0, { c: b, s: c, up: d, pr: e })
      }),
      (i.removeEventListener = function (a, b) {
        var c,
          d = this._listeners[a]
        if (d) for (c = d.length; --c > -1; ) if (d[c].c === b) return void d.splice(c, 1)
      }),
      (i.dispatchEvent = function (a) {
        var b,
          c,
          d,
          e = this._listeners[a]
        if (e)
          for (b = e.length, b > 1 && (e = e.slice(0)), c = this._eventTarget; --b > -1; )
            (d = e[b]), d && (d.up ? d.c.call(d.s || c, { type: a, target: c }) : d.c.call(d.s || c))
      })
    var A = a.requestAnimationFrame,
      B = a.cancelAnimationFrame,
      C =
        Date.now ||
        function () {
          return new Date().getTime()
        },
      D = C()
    for (g = ['ms', 'moz', 'webkit', 'o'], h = g.length; --h > -1 && !A; )
      (A = a[g[h] + 'RequestAnimationFrame']), (B = a[g[h] + 'CancelAnimationFrame'] || a[g[h] + 'CancelRequestAnimationFrame'])
    u('Ticker', function (a, b) {
      var c,
        e,
        f,
        g,
        h,
        i = this,
        l = C(),
        m = b !== !1 && A ? 'auto' : !1,
        o = 500,
        q = 33,
        r = 'tick',
        s = function (a) {
          var b,
            d,
            j = C() - D
          j > o && (l += j - q),
            (D += j),
            (i.time = (D - l) / 1e3),
            (b = i.time - h),
            (!c || b > 0 || a === !0) && (i.frame++, (h += b + (b >= g ? 0.004 : g - b)), (d = !0)),
            a !== !0 && (f = e(s)),
            d && i.dispatchEvent(r)
        }
      z.call(i),
        (i.time = i.frame = 0),
        (i.tick = function () {
          s(!0)
        }),
        (i.lagSmoothing = function (a, b) {
          return arguments.length ? ((o = a || 1 / n), void (q = Math.min(b, o, 0))) : 1 / n > o
        }),
        (i.sleep = function () {
          null != f && (m && B ? B(f) : clearTimeout(f), (e = p), (f = null), i === j && (k = !1))
        }),
        (i.wake = function (a) {
          null !== f ? i.sleep() : a ? (l += -D + (D = C())) : i.frame > 10 && (D = C() - o + 5),
            (e =
              0 === c
                ? p
                : m && A
                ? A
                : function (a) {
                    return setTimeout(a, (1e3 * (h - i.time) + 1) | 0)
                  }),
            i === j && (k = !0),
            s(2)
        }),
        (i.fps = function (a) {
          return arguments.length ? ((c = a), (g = 1 / (c || 60)), (h = this.time + g), void i.wake()) : c
        }),
        (i.useRAF = function (a) {
          return arguments.length ? (i.sleep(), (m = a), void i.fps(c)) : m
        }),
        i.fps(a),
        setTimeout(function () {
          'auto' === m && i.frame < 5 && 'hidden' !== (d || {}).visibilityState && i.useRAF(!1)
        }, 1500)
    }),
      (i = m.Ticker.prototype = new m.events.EventDispatcher()),
      (i.constructor = m.Ticker)
    var E = u('core.Animation', function (a, b) {
      if (
        ((this.vars = b = b || {}),
        (this._duration = this._totalDuration = a || 0),
        (this._delay = Number(b.delay) || 0),
        (this._timeScale = 1),
        (this._active = !!b.immediateRender),
        (this.data = b.data),
        (this._reversed = !!b.reversed),
        Z)
      ) {
        k || j.wake()
        var c = this.vars.useFrames ? Y : Z
        c.add(this, c._time), this.vars.paused && this.paused(!0)
      }
    })
    ;(j = E.ticker = new m.Ticker()),
      (i = E.prototype),
      (i._dirty = i._gc = i._initted = i._paused = !1),
      (i._totalTime = i._time = 0),
      (i._rawPrevTime = -1),
      (i._next = i._last = i._onUpdate = i._timeline = i.timeline = null),
      (i._paused = !1)
    var F = function () {
      k && C() - D > 2e3 && ('hidden' !== (d || {}).visibilityState || !j.lagSmoothing()) && j.wake()
      var a = setTimeout(F, 2e3)
      a.unref && a.unref()
    }
    F(),
      (i.play = function (a, b) {
        return null != a && this.seek(a, b), this.reversed(!1).paused(!1)
      }),
      (i.pause = function (a, b) {
        return null != a && this.seek(a, b), this.paused(!0)
      }),
      (i.resume = function (a, b) {
        return null != a && this.seek(a, b), this.paused(!1)
      }),
      (i.seek = function (a, b) {
        return this.totalTime(Number(a), b !== !1)
      }),
      (i.restart = function (a, b) {
        return this.reversed(!1)
          .paused(!1)
          .totalTime(a ? -this._delay : 0, b !== !1, !0)
      }),
      (i.reverse = function (a, b) {
        return null != a && this.seek(a || this.totalDuration(), b), this.reversed(!0).paused(!1)
      }),
      (i.render = function (a, b, c) {}),
      (i.invalidate = function () {
        return (this._time = this._totalTime = 0), (this._initted = this._gc = !1), (this._rawPrevTime = -1), (this._gc || !this.timeline) && this._enabled(!0), this
      }),
      (i.isActive = function () {
        var a,
          b = this._timeline,
          c = this._startTime
        return !b || (!this._gc && !this._paused && b.isActive() && (a = b.rawTime(!0)) >= c && a < c + this.totalDuration() / this._timeScale - n)
      }),
      (i._enabled = function (a, b) {
        return (
          k || j.wake(),
          (this._gc = !a),
          (this._active = this.isActive()),
          b !== !0 && (a && !this.timeline ? this._timeline.add(this, this._startTime - this._delay) : !a && this.timeline && this._timeline._remove(this, !0)),
          !1
        )
      }),
      (i._kill = function (a, b) {
        return this._enabled(!1, !1)
      }),
      (i.kill = function (a, b) {
        return this._kill(a, b), this
      }),
      (i._uncache = function (a) {
        for (var b = a ? this : this.timeline; b; ) (b._dirty = !0), (b = b.timeline)
        return this
      }),
      (i._swapSelfInParams = function (a) {
        for (var b = a.length, c = a.concat(); --b > -1; ) '{self}' === a[b] && (c[b] = this)
        return c
      }),
      (i._callback = function (a) {
        var b = this.vars,
          c = b[a],
          d = b[a + 'Params'],
          e = b[a + 'Scope'] || b.callbackScope || this,
          f = d ? d.length : 0
        switch (f) {
          case 0:
            c.call(e)
            break
          case 1:
            c.call(e, d[0])
            break
          case 2:
            c.call(e, d[0], d[1])
            break
          default:
            c.apply(e, d)
        }
      }),
      (i.eventCallback = function (a, b, c, d) {
        if ('on' === (a || '').substr(0, 2)) {
          var e = this.vars
          if (1 === arguments.length) return e[a]
          null == b ? delete e[a] : ((e[a] = b), (e[a + 'Params'] = q(c) && -1 !== c.join('').indexOf('{self}') ? this._swapSelfInParams(c) : c), (e[a + 'Scope'] = d)),
            'onUpdate' === a && (this._onUpdate = b)
        }
        return this
      }),
      (i.delay = function (a) {
        return arguments.length ? (this._timeline.smoothChildTiming && this.startTime(this._startTime + a - this._delay), (this._delay = a), this) : this._delay
      }),
      (i.duration = function (a) {
        return arguments.length
          ? ((this._duration = this._totalDuration = a),
            this._uncache(!0),
            this._timeline.smoothChildTiming && this._time > 0 && this._time < this._duration && 0 !== a && this.totalTime(this._totalTime * (a / this._duration), !0),
            this)
          : ((this._dirty = !1), this._duration)
      }),
      (i.totalDuration = function (a) {
        return (this._dirty = !1), arguments.length ? this.duration(a) : this._totalDuration
      }),
      (i.time = function (a, b) {
        return arguments.length ? (this._dirty && this.totalDuration(), this.totalTime(a > this._duration ? this._duration : a, b)) : this._time
      }),
      (i.totalTime = function (a, b, c) {
        if ((k || j.wake(), !arguments.length)) return this._totalTime
        if (this._timeline) {
          if ((0 > a && !c && (a += this.totalDuration()), this._timeline.smoothChildTiming)) {
            this._dirty && this.totalDuration()
            var d = this._totalDuration,
              e = this._timeline
            if (
              (a > d && !c && (a = d),
              (this._startTime = (this._paused ? this._pauseTime : e._time) - (this._reversed ? d - a : a) / this._timeScale),
              e._dirty || this._uncache(!1),
              e._timeline)
            )
              for (; e._timeline; ) e._timeline._time !== (e._startTime + e._totalTime) / e._timeScale && e.totalTime(e._totalTime, !0), (e = e._timeline)
          }
          this._gc && this._enabled(!0, !1), (this._totalTime !== a || 0 === this._duration) && (K.length && _(), this.render(a, b, !1), K.length && _())
        }
        return this
      }),
      (i.progress = i.totalProgress =
        function (a, b) {
          var c = this.duration()
          return arguments.length ? this.totalTime(c * a, b) : c ? this._time / c : this.ratio
        }),
      (i.startTime = function (a) {
        return arguments.length
          ? (a !== this._startTime && ((this._startTime = a), this.timeline && this.timeline._sortChildren && this.timeline.add(this, a - this._delay)), this)
          : this._startTime
      }),
      (i.endTime = function (a) {
        return this._startTime + (0 != a ? this.totalDuration() : this.duration()) / this._timeScale
      }),
      (i.timeScale = function (a) {
        if (!arguments.length) return this._timeScale
        var b, c
        for (
          a = a || n,
            this._timeline &&
              this._timeline.smoothChildTiming &&
              ((b = this._pauseTime), (c = b || 0 === b ? b : this._timeline.totalTime()), (this._startTime = c - ((c - this._startTime) * this._timeScale) / a)),
            this._timeScale = a,
            c = this.timeline;
          c && c.timeline;

        )
          (c._dirty = !0), c.totalDuration(), (c = c.timeline)
        return this
      }),
      (i.reversed = function (a) {
        return arguments.length
          ? (a != this._reversed &&
              ((this._reversed = a), this.totalTime(this._timeline && !this._timeline.smoothChildTiming ? this.totalDuration() - this._totalTime : this._totalTime, !0)),
            this)
          : this._reversed
      }),
      (i.paused = function (a) {
        if (!arguments.length) return this._paused
        var b,
          c,
          d = this._timeline
        return (
          a != this._paused &&
            d &&
            (k || a || j.wake(),
            (b = d.rawTime()),
            (c = b - this._pauseTime),
            !a && d.smoothChildTiming && ((this._startTime += c), this._uncache(!1)),
            (this._pauseTime = a ? b : null),
            (this._paused = a),
            (this._active = this.isActive()),
            !a &&
              0 !== c &&
              this._initted &&
              this.duration() &&
              ((b = d.smoothChildTiming ? this._totalTime : (b - this._startTime) / this._timeScale), this.render(b, b === this._totalTime, !0))),
          this._gc && !a && this._enabled(!0, !1),
          this
        )
      })
    var G = u('core.SimpleTimeline', function (a) {
      E.call(this, 0, a), (this.autoRemoveChildren = this.smoothChildTiming = !0)
    })
    ;(i = G.prototype = new E()),
      (i.constructor = G),
      (i.kill()._gc = !1),
      (i._first = i._last = i._recent = null),
      (i._sortChildren = !1),
      (i.add = i.insert =
        function (a, b, c, d) {
          var e, f
          if (
            ((a._startTime = Number(b || 0) + a._delay),
            a._paused && this !== a._timeline && (a._pauseTime = this.rawTime() - (a._timeline.rawTime() - a._pauseTime)),
            a.timeline && a.timeline._remove(a, !0),
            (a.timeline = a._timeline = this),
            a._gc && a._enabled(!0, !0),
            (e = this._last),
            this._sortChildren)
          )
            for (f = a._startTime; e && e._startTime > f; ) e = e._prev
          return (
            e ? ((a._next = e._next), (e._next = a)) : ((a._next = this._first), (this._first = a)),
            a._next ? (a._next._prev = a) : (this._last = a),
            (a._prev = e),
            (this._recent = a),
            this._timeline && this._uncache(!0),
            this
          )
        }),
      (i._remove = function (a, b) {
        return (
          a.timeline === this &&
            (b || a._enabled(!1, !0),
            a._prev ? (a._prev._next = a._next) : this._first === a && (this._first = a._next),
            a._next ? (a._next._prev = a._prev) : this._last === a && (this._last = a._prev),
            (a._next = a._prev = a.timeline = null),
            a === this._recent && (this._recent = this._last),
            this._timeline && this._uncache(!0)),
          this
        )
      }),
      (i.render = function (a, b, c) {
        var d,
          e = this._first
        for (this._totalTime = this._time = this._rawPrevTime = a; e; )
          (d = e._next),
            (e._active || (a >= e._startTime && !e._paused && !e._gc)) &&
              (e._reversed
                ? e.render((e._dirty ? e.totalDuration() : e._totalDuration) - (a - e._startTime) * e._timeScale, b, c)
                : e.render((a - e._startTime) * e._timeScale, b, c)),
            (e = d)
      }),
      (i.rawTime = function () {
        return k || j.wake(), this._totalTime
      })
    var H = u(
        'TweenLite',
        function (b, c, d) {
          if ((E.call(this, c, d), (this.render = H.prototype.render), null == b)) throw 'Cannot tween a null target.'
          this.target = b = 'string' != typeof b ? b : H.selector(b) || b
          var e,
            f,
            g,
            h = b.jquery || (b.length && b !== a && b[0] && (b[0] === a || (b[0].nodeType && b[0].style && !b.nodeType))),
            i = this.vars.overwrite
          if (
            ((this._overwrite = i = null == i ? X[H.defaultOverwrite] : 'number' == typeof i ? i >> 0 : X[i]),
            (h || b instanceof Array || (b.push && q(b))) && 'number' != typeof b[0])
          )
            for (this._targets = g = o(b), this._propLookup = [], this._siblings = [], e = 0; e < g.length; e++)
              (f = g[e]),
                f
                  ? 'string' != typeof f
                    ? f.length && f !== a && f[0] && (f[0] === a || (f[0].nodeType && f[0].style && !f.nodeType))
                      ? (g.splice(e--, 1), (this._targets = g = g.concat(o(f))))
                      : ((this._siblings[e] = aa(f, this, !1)), 1 === i && this._siblings[e].length > 1 && ca(f, this, null, 1, this._siblings[e]))
                    : ((f = g[e--] = H.selector(f)), 'string' == typeof f && g.splice(e + 1, 1))
                  : g.splice(e--, 1)
          else (this._propLookup = {}), (this._siblings = aa(b, this, !1)), 1 === i && this._siblings.length > 1 && ca(b, this, null, 1, this._siblings)
          ;(this.vars.immediateRender || (0 === c && 0 === this._delay && this.vars.immediateRender !== !1)) &&
            ((this._time = -n), this.render(Math.min(0, -this._delay)))
        },
        !0
      ),
      I = function (b) {
        return b && b.length && b !== a && b[0] && (b[0] === a || (b[0].nodeType && b[0].style && !b.nodeType))
      },
      J = function (a, b) {
        var c,
          d = {}
        for (c in a)
          W[c] ||
            (c in b && 'transform' !== c && 'x' !== c && 'y' !== c && 'width' !== c && 'height' !== c && 'className' !== c && 'border' !== c) ||
            !(!T[c] || (T[c] && T[c]._autoCSS)) ||
            ((d[c] = a[c]), delete a[c])
        a.css = d
      }
    ;(i = H.prototype = new E()),
      (i.constructor = H),
      (i.kill()._gc = !1),
      (i.ratio = 0),
      (i._firstPT = i._targets = i._overwrittenProps = i._startAt = null),
      (i._notifyPluginsOfEnabled = i._lazy = !1),
      (H.version = '2.1.2'),
      (H.defaultEase = i._ease = new w(null, null, 1, 1)),
      (H.defaultOverwrite = 'auto'),
      (H.ticker = j),
      (H.autoSleep = 120),
      (H.lagSmoothing = function (a, b) {
        j.lagSmoothing(a, b)
      }),
      (H.selector =
        a.$ ||
        a.jQuery ||
        function (b) {
          var c = a.$ || a.jQuery
          return c
            ? ((H.selector = c), c(b))
            : (d || (d = a.document), d ? (d.querySelectorAll ? d.querySelectorAll(b) : d.getElementById('#' === b.charAt(0) ? b.substr(1) : b)) : b)
        })
    var K = [],
      L = {},
      M = /(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi,
      N = /[\+-]=-?[\.\d]/,
      O = function (a) {
        for (var b, c = this._firstPT, d = 1e-6; c; )
          (b = c.blob ? (1 === a && null != this.end ? this.end : a ? this.join('') : this.start) : c.c * a + c.s),
            c.m ? (b = c.m.call(this._tween, b, this._target || c.t, this._tween)) : d > b && b > -d && !c.blob && (b = 0),
            c.f ? (c.fp ? c.t[c.p](c.fp, b) : c.t[c.p](b)) : (c.t[c.p] = b),
            (c = c._next)
      },
      P = function (a) {
        return ((1e3 * a) | 0) / 1e3 + ''
      },
      Q = function (a, b, c, d) {
        var e,
          f,
          g,
          h,
          i,
          j,
          k,
          l = [],
          m = 0,
          n = '',
          o = 0
        for (
          l.start = a,
            l.end = b,
            a = l[0] = a + '',
            b = l[1] = b + '',
            c && (c(l), (a = l[0]), (b = l[1])),
            l.length = 0,
            e = a.match(M) || [],
            f = b.match(M) || [],
            d && ((d._next = null), (d.blob = 1), (l._firstPT = l._applyPT = d)),
            i = f.length,
            h = 0;
          i > h;
          h++
        )
          (k = f[h]),
            (j = b.substr(m, b.indexOf(k, m) - m)),
            (n += j || !h ? j : ','),
            (m += j.length),
            o ? (o = (o + 1) % 5) : 'rgba(' === j.substr(-5) && (o = 1),
            k === e[h] || e.length <= h
              ? (n += k)
              : (n && (l.push(n), (n = '')),
                (g = parseFloat(e[h])),
                l.push(g),
                (l._firstPT = {
                  _next: l._firstPT,
                  t: l,
                  p: l.length - 1,
                  s: g,
                  c: ('=' === k.charAt(1) ? parseInt(k.charAt(0) + '1', 10) * parseFloat(k.substr(2)) : parseFloat(k) - g) || 0,
                  f: 0,
                  m: o && 4 > o ? Math.round : P
                })),
            (m += k.length)
        return (n += b.substr(m)), n && l.push(n), (l.setRatio = O), N.test(b) && (l.end = null), l
      },
      R = function (a, b, c, d, e, f, g, h, i) {
        'function' == typeof d && (d = d(i || 0, a))
        var j,
          k = typeof a[b],
          l = 'function' !== k ? '' : b.indexOf('set') || 'function' != typeof a['get' + b.substr(3)] ? b : 'get' + b.substr(3),
          m = 'get' !== c ? c : l ? (g ? a[l](g) : a[l]()) : a[b],
          n = 'string' == typeof d && '=' === d.charAt(1),
          o = {
            t: a,
            p: b,
            s: m,
            f: 'function' === k,
            pg: 0,
            n: e || b,
            m: f ? ('function' == typeof f ? f : Math.round) : 0,
            pr: 0,
            c: n ? parseInt(d.charAt(0) + '1', 10) * parseFloat(d.substr(2)) : parseFloat(d) - m || 0
          }
        return (
          ('number' != typeof m || ('number' != typeof d && !n)) &&
            (g || isNaN(m) || (!n && isNaN(d)) || 'boolean' == typeof m || 'boolean' == typeof d
              ? ((o.fp = g),
                (j = Q(m, n ? parseFloat(o.s) + o.c + (o.s + '').replace(/[0-9\-\.]/g, '') : d, h || H.defaultStringFilter, o)),
                (o = { t: j, p: 'setRatio', s: 0, c: 1, f: 2, pg: 0, n: e || b, pr: 0, m: 0 }))
              : ((o.s = parseFloat(m)), n || (o.c = parseFloat(d) - o.s || 0))),
          o.c ? ((o._next = this._firstPT) && (o._next._prev = o), (this._firstPT = o), o) : void 0
        )
      },
      S = (H._internals = { isArray: q, isSelector: I, lazyTweens: K, blobDif: Q }),
      T = (H._plugins = {}),
      U = (S.tweenLookup = {}),
      V = 0,
      W = (S.reservedProps = {
        ease: 1,
        delay: 1,
        overwrite: 1,
        onComplete: 1,
        onCompleteParams: 1,
        onCompleteScope: 1,
        useFrames: 1,
        runBackwards: 1,
        startAt: 1,
        onUpdate: 1,
        onUpdateParams: 1,
        onUpdateScope: 1,
        onStart: 1,
        onStartParams: 1,
        onStartScope: 1,
        onReverseComplete: 1,
        onReverseCompleteParams: 1,
        onReverseCompleteScope: 1,
        onRepeat: 1,
        onRepeatParams: 1,
        onRepeatScope: 1,
        easeParams: 1,
        yoyo: 1,
        immediateRender: 1,
        repeat: 1,
        repeatDelay: 1,
        data: 1,
        paused: 1,
        reversed: 1,
        autoCSS: 1,
        lazy: 1,
        onOverwrite: 1,
        callbackScope: 1,
        stringFilter: 1,
        id: 1,
        yoyoEase: 1,
        stagger: 1
      }),
      X = { none: 0, all: 1, auto: 2, concurrent: 3, allOnStart: 4, preexisting: 5, true: 1, false: 0 },
      Y = (E._rootFramesTimeline = new G()),
      Z = (E._rootTimeline = new G()),
      $ = 30,
      _ = (S.lazyRender = function () {
        var a,
          b,
          c = K.length
        for (L = {}, a = 0; c > a; a++) (b = K[a]), b && b._lazy !== !1 && (b.render(b._lazy[0], b._lazy[1], !0), (b._lazy = !1))
        K.length = 0
      })
    ;(Z._startTime = j.time),
      (Y._startTime = j.frame),
      (Z._active = Y._active = !0),
      setTimeout(_, 1),
      (E._updateRoot = H.render =
        function () {
          var a, b, c
          if (
            (K.length && _(),
            Z.render((j.time - Z._startTime) * Z._timeScale, !1, !1),
            Y.render((j.frame - Y._startTime) * Y._timeScale, !1, !1),
            K.length && _(),
            j.frame >= $)
          ) {
            $ = j.frame + (parseInt(H.autoSleep, 10) || 120)
            for (c in U) {
              for (b = U[c].tweens, a = b.length; --a > -1; ) b[a]._gc && b.splice(a, 1)
              0 === b.length && delete U[c]
            }
            if (((c = Z._first), (!c || c._paused) && H.autoSleep && !Y._first && 1 === j._listeners.tick.length)) {
              for (; c && c._paused; ) c = c._next
              c || j.sleep()
            }
          }
        }),
      j.addEventListener('tick', E._updateRoot)
    var aa = function (a, b, c) {
        var d,
          e,
          f = a._gsTweenID
        if ((U[f || (a._gsTweenID = f = 't' + V++)] || (U[f] = { target: a, tweens: [] }), b && ((d = U[f].tweens), (d[(e = d.length)] = b), c)))
          for (; --e > -1; ) d[e] === b && d.splice(e, 1)
        return U[f].tweens
      },
      ba = function (a, b, c, d) {
        var e,
          f,
          g = a.vars.onOverwrite
        return g && (e = g(a, b, c, d)), (g = H.onOverwrite), g && (f = g(a, b, c, d)), e !== !1 && f !== !1
      },
      ca = function (a, b, c, d, e) {
        var f, g, h, i
        if (1 === d || d >= 4) {
          for (i = e.length, f = 0; i > f; f++)
            if ((h = e[f]) !== b) h._gc || (h._kill(null, a, b) && (g = !0))
            else if (5 === d) break
          return g
        }
        var j,
          k = b._startTime + n,
          l = [],
          m = 0,
          o = 0 === b._duration
        for (f = e.length; --f > -1; )
          (h = e[f]) === b ||
            h._gc ||
            h._paused ||
            (h._timeline !== b._timeline
              ? ((j = j || da(b, 0, o)), 0 === da(h, j, o) && (l[m++] = h))
              : h._startTime <= k && h._startTime + h.totalDuration() / h._timeScale > k && (((o || !h._initted) && k - h._startTime <= 2 * n) || (l[m++] = h)))
        for (f = m; --f > -1; )
          if (((h = l[f]), (i = h._firstPT), 2 === d && h._kill(c, a, b) && (g = !0), 2 !== d || (!h._firstPT && h._initted && i))) {
            if (2 !== d && !ba(h, b)) continue
            h._enabled(!1, !1) && (g = !0)
          }
        return g
      },
      da = function (a, b, c) {
        for (var d = a._timeline, e = d._timeScale, f = a._startTime; d._timeline; ) {
          if (((f += d._startTime), (e *= d._timeScale), d._paused)) return -100
          d = d._timeline
        }
        return (f /= e), f > b ? f - b : (c && f === b) || (!a._initted && 2 * n > f - b) ? n : (f += a.totalDuration() / a._timeScale / e) > b + n ? 0 : f - b - n
      }
    ;(i._init = function () {
      var a,
        b,
        c,
        d,
        e,
        f,
        g = this.vars,
        h = this._overwrittenProps,
        i = this._duration,
        j = !!g.immediateRender,
        k = g.ease,
        l = this._startAt
      if (g.startAt) {
        l && (l.render(-1, !0), l.kill()), (e = {})
        for (d in g.startAt) e[d] = g.startAt[d]
        if (
          ((e.data = 'isStart'),
          (e.overwrite = !1),
          (e.immediateRender = !0),
          (e.lazy = j && g.lazy !== !1),
          (e.startAt = e.delay = null),
          (e.onUpdate = g.onUpdate),
          (e.onUpdateParams = g.onUpdateParams),
          (e.onUpdateScope = g.onUpdateScope || g.callbackScope || this),
          (this._startAt = H.to(this.target || {}, 0, e)),
          j)
        )
          if (this._time > 0) this._startAt = null
          else if (0 !== i) return
      } else if (g.runBackwards && 0 !== i)
        if (l) l.render(-1, !0), l.kill(), (this._startAt = null)
        else {
          0 !== this._time && (j = !1), (c = {})
          for (d in g) (W[d] && 'autoCSS' !== d) || (c[d] = g[d])
          if (((c.overwrite = 0), (c.data = 'isFromStart'), (c.lazy = j && g.lazy !== !1), (c.immediateRender = j), (this._startAt = H.to(this.target, 0, c)), j)) {
            if (0 === this._time) return
          } else this._startAt._init(), this._startAt._enabled(!1), this.vars.immediateRender && (this._startAt = null)
        }
      if (
        ((this._ease = k = k ? (k instanceof w ? k : 'function' == typeof k ? new w(k, g.easeParams) : x[k] || H.defaultEase) : H.defaultEase),
        g.easeParams instanceof Array && k.config && (this._ease = k.config.apply(k, g.easeParams)),
        (this._easeType = this._ease._type),
        (this._easePower = this._ease._power),
        (this._firstPT = null),
        this._targets)
      )
        for (f = this._targets.length, a = 0; f > a; a++) this._initProps(this._targets[a], (this._propLookup[a] = {}), this._siblings[a], h ? h[a] : null, a) && (b = !0)
      else b = this._initProps(this.target, this._propLookup, this._siblings, h, 0)
      if ((b && H._onPluginEvent('_onInitAllProps', this), h && (this._firstPT || ('function' != typeof this.target && this._enabled(!1, !1))), g.runBackwards))
        for (c = this._firstPT; c; ) (c.s += c.c), (c.c = -c.c), (c = c._next)
      ;(this._onUpdate = g.onUpdate), (this._initted = !0)
    }),
      (i._initProps = function (b, c, d, e, f) {
        var g, h, i, j, k, l
        if (null == b) return !1
        L[b._gsTweenID] && _(), this.vars.css || (b.style && b !== a && b.nodeType && T.css && this.vars.autoCSS !== !1 && J(this.vars, b))
        for (g in this.vars)
          if (((l = this.vars[g]), W[g]))
            l && (l instanceof Array || (l.push && q(l))) && -1 !== l.join('').indexOf('{self}') && (this.vars[g] = l = this._swapSelfInParams(l, this))
          else if (T[g] && (j = new T[g]())._onInitTween(b, this.vars[g], this, f)) {
            for (
              this._firstPT = k = { _next: this._firstPT, t: j, p: 'setRatio', s: 0, c: 1, f: 1, n: g, pg: 1, pr: j._priority, m: 0 }, h = j._overwriteProps.length;
              --h > -1;

            )
              c[j._overwriteProps[h]] = this._firstPT
            ;(j._priority || j._onInitAllProps) && (i = !0), (j._onDisable || j._onEnable) && (this._notifyPluginsOfEnabled = !0), k._next && (k._next._prev = k)
          } else c[g] = R.call(this, b, g, 'get', l, g, 0, null, this.vars.stringFilter, f)
        return e && this._kill(e, b)
          ? this._initProps(b, c, d, e, f)
          : this._overwrite > 1 && this._firstPT && d.length > 1 && ca(b, this, c, this._overwrite, d)
          ? (this._kill(c, b), this._initProps(b, c, d, e, f))
          : (this._firstPT && ((this.vars.lazy !== !1 && this._duration) || (this.vars.lazy && !this._duration)) && (L[b._gsTweenID] = !0), i)
      }),
      (i.render = function (a, b, c) {
        var d,
          e,
          f,
          g,
          h = this,
          i = h._time,
          j = h._duration,
          k = h._rawPrevTime
        if (a >= j - n && a >= 0)
          (h._totalTime = h._time = j),
            (h.ratio = h._ease._calcEnd ? h._ease.getRatio(1) : 1),
            h._reversed || ((d = !0), (e = 'onComplete'), (c = c || h._timeline.autoRemoveChildren)),
            0 === j &&
              (h._initted || !h.vars.lazy || c) &&
              (h._startTime === h._timeline._duration && (a = 0),
              (0 > k || (0 >= a && a >= -n) || (k === n && 'isPause' !== h.data)) && k !== a && ((c = !0), k > n && (e = 'onReverseComplete')),
              (h._rawPrevTime = g = !b || a || k === a ? a : n))
        else if (n > a)
          (h._totalTime = h._time = 0),
            (h.ratio = h._ease._calcEnd ? h._ease.getRatio(0) : 0),
            (0 !== i || (0 === j && k > 0)) && ((e = 'onReverseComplete'), (d = h._reversed)),
            a > -n
              ? (a = 0)
              : 0 > a &&
                ((h._active = !1),
                0 === j &&
                  (h._initted || !h.vars.lazy || c) &&
                  (k >= 0 && (k !== n || 'isPause' !== h.data) && (c = !0), (h._rawPrevTime = g = !b || a || k === a ? a : n))),
            (!h._initted || (h._startAt && h._startAt.progress())) && (c = !0)
        else if (((h._totalTime = h._time = a), h._easeType)) {
          var l = a / j,
            m = h._easeType,
            o = h._easePower
          ;(1 === m || (3 === m && l >= 0.5)) && (l = 1 - l),
            3 === m && (l *= 2),
            1 === o ? (l *= l) : 2 === o ? (l *= l * l) : 3 === o ? (l *= l * l * l) : 4 === o && (l *= l * l * l * l),
            (h.ratio = 1 === m ? 1 - l : 2 === m ? l : 0.5 > a / j ? l / 2 : 1 - l / 2)
        } else h.ratio = h._ease.getRatio(a / j)
        if (h._time !== i || c) {
          if (!h._initted) {
            if ((h._init(), !h._initted || h._gc)) return
            if (!c && h._firstPT && ((h.vars.lazy !== !1 && h._duration) || (h.vars.lazy && !h._duration)))
              return (h._time = h._totalTime = i), (h._rawPrevTime = k), K.push(h), void (h._lazy = [a, b])
            h._time && !d ? (h.ratio = h._ease.getRatio(h._time / j)) : d && h._ease._calcEnd && (h.ratio = h._ease.getRatio(0 === h._time ? 0 : 1))
          }
          for (
            h._lazy !== !1 && (h._lazy = !1),
              h._active || (!h._paused && h._time !== i && a >= 0 && (h._active = !0)),
              0 === i &&
                (h._startAt && (a >= 0 ? h._startAt.render(a, !0, c) : e || (e = '_dummyGS')),
                h.vars.onStart && (0 !== h._time || 0 === j) && (b || h._callback('onStart'))),
              f = h._firstPT;
            f;

          )
            f.f ? f.t[f.p](f.c * h.ratio + f.s) : (f.t[f.p] = f.c * h.ratio + f.s), (f = f._next)
          h._onUpdate && (0 > a && h._startAt && a !== -1e-4 && h._startAt.render(a, !0, c), b || ((h._time !== i || d || c) && h._callback('onUpdate'))),
            e &&
              (!h._gc || c) &&
              (0 > a && h._startAt && !h._onUpdate && a !== -1e-4 && h._startAt.render(a, !0, c),
              d && (h._timeline.autoRemoveChildren && h._enabled(!1, !1), (h._active = !1)),
              !b && h.vars[e] && h._callback(e),
              0 === j && h._rawPrevTime === n && g !== n && (h._rawPrevTime = 0))
        }
      }),
      (i._kill = function (a, b, c) {
        if (('all' === a && (a = null), null == a && (null == b || b === this.target))) return (this._lazy = !1), this._enabled(!1, !1)
        b = 'string' != typeof b ? b || this._targets || this.target : H.selector(b) || b
        var d,
          e,
          f,
          g,
          h,
          i,
          j,
          k,
          l,
          m = c && this._time && c._startTime === this._startTime && this._timeline === c._timeline,
          n = this._firstPT
        if ((q(b) || I(b)) && 'number' != typeof b[0]) for (d = b.length; --d > -1; ) this._kill(a, b[d], c) && (i = !0)
        else {
          if (this._targets) {
            for (d = this._targets.length; --d > -1; )
              if (b === this._targets[d]) {
                ;(h = this._propLookup[d] || {}),
                  (this._overwrittenProps = this._overwrittenProps || []),
                  (e = this._overwrittenProps[d] = a ? this._overwrittenProps[d] || {} : 'all')
                break
              }
          } else {
            if (b !== this.target) return !1
            ;(h = this._propLookup), (e = this._overwrittenProps = a ? this._overwrittenProps || {} : 'all')
          }
          if (h) {
            if (((j = a || h), (k = a !== e && 'all' !== e && a !== h && ('object' != typeof a || !a._tempKill)), c && (H.onOverwrite || this.vars.onOverwrite))) {
              for (f in j) h[f] && (l || (l = []), l.push(f))
              if ((l || !a) && !ba(this, c, b, l)) return !1
            }
            for (f in j)
              (g = h[f]) &&
                (m && (g.f ? g.t[g.p](g.s) : (g.t[g.p] = g.s), (i = !0)),
                g.pg && g.t._kill(j) && (i = !0),
                (g.pg && 0 !== g.t._overwriteProps.length) ||
                  (g._prev ? (g._prev._next = g._next) : g === this._firstPT && (this._firstPT = g._next),
                  g._next && (g._next._prev = g._prev),
                  (g._next = g._prev = null)),
                delete h[f]),
                k && (e[f] = 1)
            !this._firstPT && this._initted && n && this._enabled(!1, !1)
          }
        }
        return i
      }),
      (i.invalidate = function () {
        this._notifyPluginsOfEnabled && H._onPluginEvent('_onDisable', this)
        var a = this._time
        return (
          (this._firstPT = this._overwrittenProps = this._startAt = this._onUpdate = null),
          (this._notifyPluginsOfEnabled = this._active = this._lazy = !1),
          (this._propLookup = this._targets ? {} : []),
          E.prototype.invalidate.call(this),
          this.vars.immediateRender && ((this._time = -n), this.render(a, !1, this.vars.lazy !== !1)),
          this
        )
      }),
      (i._enabled = function (a, b) {
        if ((k || j.wake(), a && this._gc)) {
          var c,
            d = this._targets
          if (d) for (c = d.length; --c > -1; ) this._siblings[c] = aa(d[c], this, !0)
          else this._siblings = aa(this.target, this, !0)
        }
        return E.prototype._enabled.call(this, a, b), this._notifyPluginsOfEnabled && this._firstPT ? H._onPluginEvent(a ? '_onEnable' : '_onDisable', this) : !1
      }),
      (H.to = function (a, b, c) {
        return new H(a, b, c)
      }),
      (H.from = function (a, b, c) {
        return (c.runBackwards = !0), (c.immediateRender = 0 != c.immediateRender), new H(a, b, c)
      }),
      (H.fromTo = function (a, b, c, d) {
        return (d.startAt = c), (d.immediateRender = 0 != d.immediateRender && 0 != c.immediateRender), new H(a, b, d)
      }),
      (H.delayedCall = function (a, b, c, d, e) {
        return new H(b, 0, {
          delay: a,
          onComplete: b,
          onCompleteParams: c,
          callbackScope: d,
          onReverseComplete: b,
          onReverseCompleteParams: c,
          immediateRender: !1,
          lazy: !1,
          useFrames: e,
          overwrite: 0
        })
      }),
      (H.set = function (a, b) {
        return new H(a, 0, b)
      }),
      (H.getTweensOf = function (a, b) {
        if (null == a) return []
        a = 'string' != typeof a ? a : H.selector(a) || a
        var c, d, e, f
        if ((q(a) || I(a)) && 'number' != typeof a[0]) {
          for (c = a.length, d = []; --c > -1; ) d = d.concat(H.getTweensOf(a[c], b))
          for (c = d.length; --c > -1; ) for (f = d[c], e = c; --e > -1; ) f === d[e] && d.splice(c, 1)
        } else if (a._gsTweenID) for (d = aa(a).concat(), c = d.length; --c > -1; ) (d[c]._gc || (b && !d[c].isActive())) && d.splice(c, 1)
        return d || []
      }),
      (H.killTweensOf = H.killDelayedCallsTo =
        function (a, b, c) {
          'object' == typeof b && ((c = b), (b = !1))
          for (var d = H.getTweensOf(a, b), e = d.length; --e > -1; ) d[e]._kill(c, a)
        })
    var ea = u(
      'plugins.TweenPlugin',
      function (a, b) {
        ;(this._overwriteProps = (a || '').split(',')), (this._propName = this._overwriteProps[0]), (this._priority = b || 0), (this._super = ea.prototype)
      },
      !0
    )
    if (
      ((i = ea.prototype),
      (ea.version = '1.19.0'),
      (ea.API = 2),
      (i._firstPT = null),
      (i._addTween = R),
      (i.setRatio = O),
      (i._kill = function (a) {
        var b,
          c = this._overwriteProps,
          d = this._firstPT
        if (null != a[this._propName]) this._overwriteProps = []
        else for (b = c.length; --b > -1; ) null != a[c[b]] && c.splice(b, 1)
        for (; d; )
          null != a[d.n] &&
            (d._next && (d._next._prev = d._prev), d._prev ? ((d._prev._next = d._next), (d._prev = null)) : this._firstPT === d && (this._firstPT = d._next)),
            (d = d._next)
        return !1
      }),
      (i._mod = i._roundProps =
        function (a) {
          for (var b, c = this._firstPT; c; )
            (b = a[this._propName] || (null != c.n && a[c.n.split(this._propName + '_').join('')])),
              b && 'function' == typeof b && (2 === c.f ? (c.t._applyPT.m = b) : (c.m = b)),
              (c = c._next)
        }),
      (H._onPluginEvent = function (a, b) {
        var c,
          d,
          e,
          f,
          g,
          h = b._firstPT
        if ('_onInitAllProps' === a) {
          for (; h; ) {
            for (g = h._next, d = e; d && d.pr > h.pr; ) d = d._next
            ;(h._prev = d ? d._prev : f) ? (h._prev._next = h) : (e = h), (h._next = d) ? (d._prev = h) : (f = h), (h = g)
          }
          h = b._firstPT = e
        }
        for (; h; ) h.pg && 'function' == typeof h.t[a] && h.t[a]() && (c = !0), (h = h._next)
        return c
      }),
      (ea.activate = function (a) {
        for (var b = a.length; --b > -1; ) a[b].API === ea.API && (T[new a[b]()._propName] = a[b])
        return !0
      }),
      (t.plugin = function (a) {
        if (!(a && a.propName && a.init && a.API)) throw 'illegal plugin definition.'
        var b,
          c = a.propName,
          d = a.priority || 0,
          e = a.overwriteProps,
          f = { init: '_onInitTween', set: 'setRatio', kill: '_kill', round: '_mod', mod: '_mod', initAll: '_onInitAllProps' },
          g = u(
            'plugins.' + c.charAt(0).toUpperCase() + c.substr(1) + 'Plugin',
            function () {
              ea.call(this, c, d), (this._overwriteProps = e || [])
            },
            a.global === !0
          ),
          h = (g.prototype = new ea(c))
        ;(h.constructor = g), (g.API = a.API)
        for (b in f) 'function' == typeof a[b] && (h[f[b]] = a[b])
        return (g.version = a.version), ea.activate([g]), g
      }),
      (g = a._gsQueue))
    ) {
      for (h = 0; h < g.length; h++) g[h]()
      for (i in r) r[i].func || a.console.log('GSAP encountered missing dependency: ' + i)
    }
    k = !1
  })('undefined' != typeof module && module.exports && 'undefined' != typeof global ? global : this || window, 'TweenMax')

var Stats = function () {
  function h(a) {
    c.appendChild(a.dom)
    return a
  }
  function k(a) {
    for (var d = 0; d < c.children.length; d++) c.children[d].style.display = d === a ? 'block' : 'none'
    l = a
  }
  var l = 0,
    c = document.createElement('div')
  c.style.cssText = 'position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000'
  c.addEventListener(
    'click',
    function (a) {
      a.preventDefault()
      k(++l % c.children.length)
    },
    !1
  )
  var g = (performance || Date).now(),
    e = g,
    a = 0,
    r = h(new Stats.Panel('FPS', '#0ff', '#002')),
    f = h(new Stats.Panel('MS', '#0f0', '#020'))
  if (self.performance && self.performance.memory) var t = h(new Stats.Panel('MB', '#f08', '#201'))
  k(0)
  return {
    REVISION: 16,
    dom: c,
    addPanel: h,
    showPanel: k,
    begin: function () {
      g = (performance || Date).now()
    },
    end: function () {
      a++
      var c = (performance || Date).now()
      f.update(c - g, 200)
      if (c > e + 1e3 && (r.update((1e3 * a) / (c - e), 100), (e = c), (a = 0), t)) {
        var d = performance.memory
        t.update(d.usedJSHeapSize / 1048576, d.jsHeapSizeLimit / 1048576)
      }
      return c
    },
    update: function () {
      g = this.end()
    },
    domElement: c,
    setMode: k
  }
}
Stats.Panel = function (h, k, l) {
  var c = Infinity,
    g = 0,
    e = Math.round,
    a = e(window.devicePixelRatio || 1),
    r = 80 * a,
    f = 48 * a,
    t = 3 * a,
    u = 2 * a,
    d = 3 * a,
    m = 15 * a,
    n = 74 * a,
    p = 30 * a,
    q = document.createElement('canvas')
  q.width = r
  q.height = f
  q.style.cssText = 'width:80px;height:48px'
  var b = q.getContext('2d')
  b.font = 'bold ' + 9 * a + 'px Helvetica,Arial,sans-serif'
  b.textBaseline = 'top'
  b.fillStyle = l
  b.fillRect(0, 0, r, f)
  b.fillStyle = k
  b.fillText(h, t, u)
  b.fillRect(d, m, n, p)
  b.fillStyle = l
  b.globalAlpha = 0.9
  b.fillRect(d, m, n, p)
  return {
    dom: q,
    update: function (f, v) {
      c = Math.min(c, f)
      g = Math.max(g, f)
      b.fillStyle = l
      b.globalAlpha = 1
      b.fillRect(0, 0, r, m)
      b.fillStyle = k
      b.fillText(e(f) + ' ' + h + ' (' + e(c) + '-' + e(g) + ')', t, u)
      b.drawImage(q, d + a, m, n - a, p, d, m, n - a, p)
      b.fillRect(d + n - a, m, a, p)
      b.fillStyle = l
      b.globalAlpha = 0.9
      b.fillRect(d + n - a, m, a, e((1 - f / v) * p))
    }
  }
}
'object' === typeof module && (module.exports = Stats)
/////////////////////////////////////////////////////--------------   my  line--------------
var interVal = -1,
  vIndex = 1
var mainColor = 'rgb(81, 109, 216)'
var borderColor = 'rgb(46, 78, 203)'
var arrowColor = 'rgb(255,255,255)'
var getProportionPoint2 = (point, segment, length, dx, dy) => {
  let factor = segment / length
  return { x: point.x - dx * factor, y: point.y - dy * factor }
}
var getRoundCornerBy3Points2 = ({ angularPoint, p1, p2, radius }) => {
  let dx1 = angularPoint.x - p1.x
  let dy1 = angularPoint.y - p1.y
  let dx2 = angularPoint.x - p2.x
  let dy2 = angularPoint.y - p2.y
  let angle = (Math.atan2(dy1, dx1) - Math.atan2(dy2, dx2)) / 2
  let tan = Math.abs(Math.tan(angle))
  let segment = radius / tan
  let length1 = Math.sqrt(dx1 * dx1 + dy1 * dy1)
  let length2 = Math.sqrt(dx2 * dx2 + dy2 * dy2)
  let length = Math.min(length1, length2)
  if (segment > length) {
    segment = length
    radius = length * tan
  }
  let p1Cross = getProportionPoint2(angularPoint, segment, length1, dx1, dy1)
  let p2Cross = getProportionPoint2(angularPoint, segment, length2, dx2, dy2)
  let dx = angularPoint.x * 2 - p1Cross.x - p2Cross.x
  let dy = angularPoint.y * 2 - p1Cross.y - p2Cross.y
  let L = Math.sqrt(dx * dx + dy * dy)
  let d = Math.sqrt(segment * segment + radius * radius)
  let circlePoint = getProportionPoint2(angularPoint, d, L, dx, dy)
  let startAngle = Math.atan2(p1Cross.y - circlePoint.y, p1Cross.x - circlePoint.x)
  let endAngle = Math.atan2(p2Cross.y - circlePoint.y, p2Cross.x - circlePoint.x)
  let sweepAngle = endAngle - startAngle
  if (sweepAngle < 0) {
    startAngle = endAngle
    sweepAngle = -sweepAngle
  }
  endAngle = startAngle + sweepAngle
  return { p1Cross, p2Cross, startAngle, endAngle, circlePoint }
}
var POINT = function (x, y) {
  this.x = x
  this.y = y
  this.equals = function (p) {
    return this.x === p.x && this.y === p.y
  }
  this.rotate = function (center, a, clockWise) {
    let { x, y } = this
    if (clockWise) a = -a
    let rx0 = center.x
    let ry0 = center.y
    this.x = (x - rx0) * Math.cos(a) - (y - ry0) * Math.sin(a) + rx0
    this.y = (x - rx0) * Math.sin(a) + (y - ry0) * Math.cos(a) + ry0
  }
}
var LINE = function (k, b) {
  this.k = k
  this.b = b
  this.kSign = this.k > 0 ? 1 : -1
  this.a = Math.atan(this.k)
  this.bDiff = function (offset) {
    return Math.abs(offset / Math.cos(this.a))
  }
  this.crossPoint = function (line) {
    const x = (line.b - this.b) / (this.k - line.k)
    const y = this.k * x + this.b
    return new POINT(x, y)
  }
  this.verticalCrossPoint = function (x, y) {
    let k1 = -1 / this.k
    let b1 = y - k1 * x
    let k2 = this.k
    let b2 = this.b
    let x1 = (b2 - b1) / (k1 - k2)
    let y1 = k2 * x1 + b2
    return { x: x1, y: y1 }
  }
}
var LINESEGMENT = function (p1, p2) {
  const x1 = p1.x
  const x2 = p2.x
  const y1 = p1.y
  const y2 = p2.y
  const k = (y2 - y1) / (x2 - x1)
  const b = y1 - k * x1
  LINE.call(this, k, b)
  Object.assign(this, { x1, x2, y1, y2, p1, p2 })
  this.isUp = this.y2 >= this.y1 ? 1 : -1
  this.sign = this.kSign * this.isUp
  this.xDiff = Math.abs(this.x1 - this.x2)
  this.yDiff = Math.abs(this.y1 - this.y2)
  this.length = Math.sqrt(this.xDiff * this.xDiff + this.yDiff * this.yDiff)
  this.distanceTo = function (x, y) {
    return Math.abs(this.k * x - y + this.b) / Math.sqrt(1 + this.k * this.k)
  }
  this.mirrow = function (x, y) {
    const { x: midX, y: midY } = this.verticalCrossPoint(x, y)
    return { x: midX * 2 - x, y: midY * 2 - y }
  }
  this.rightLine = function (offset) {
    return new LINE(this.k, this.b - this.sign * this.bDiff(offset))
  }
  this.leftLine = function (offset) {
    return new LINE(this.k, this.b + this.sign * this.bDiff(offset))
  }
  this.leftP1 = function (offset) {
    return new POINT(this.p1.x - this.sign * offset * Math.sin(this.a), this.p1.y + this.sign * offset * Math.cos(this.a))
  }
  this.rightP1 = function (offset) {
    return new POINT(this.p1.x + this.sign * offset * Math.sin(this.a), this.p1.y - this.sign * offset * Math.cos(this.a))
  }
  this.leftP2 = function (offset) {
    return new POINT(this.p2.x - this.sign * offset * Math.sin(this.a), this.p2.y + this.sign * offset * Math.cos(this.a))
  }
  this.rightP2 = function (offset) {
    return new POINT(this.p2.x + this.sign * offset * Math.sin(this.a), this.p2.y - this.sign * offset * Math.cos(this.a))
  }
}
var PathLine = function (radius, linePath, floorHeight) {
  THREE.Group.call(this)
  const roundCornoredPath = new THREE.Geometry()
  const rings = new THREE.Geometry()
  const arrowGeo1 = new THREE.Geometry()
  const arrowGeo2 = new THREE.Geometry()
  const arrowGeo3 = new THREE.Geometry()
  const factor = radius / 20
  const innerBorderRatio = (20 - 10) / 20
  const innerRadius = radius * innerBorderRatio
  const turnRadius = factor * 40
  const centerRadius = turnRadius - radius
  const roundFragments = (1 / 180) * Math.PI
  const ringInnerRadius = (radius / 26) * 30
  const ringOuterRadius = (radius / 26) * 56
  const ringMiddleRadius = ringOuterRadius - factor * 10
  const avgArrow = 40 * factor
  let lineSegments = []
  const h1 = floorHeight + floorHeight / 100
  const h2 = floorHeight + floorHeight / 50
  const addFace = (geometry, p1, p2, theta, clockWise) => {
    const index = { a: 0, b: 1, c: 2, d: 3, e: 4, f: 5, g: 6, h: 7 }
    const faces = [
      ['a', 'b', 'd', borderColor],
      ['a', 'c', 'd', borderColor],
      ['c', 'd', 'f', mainColor],
      ['c', 'e', 'f', mainColor],
      ['e', 'f', 'h', borderColor],
      ['e', 'g', 'h', borderColor]
    ]
    let length = geometry.vertices.length
    let lineSegment = new LINESEGMENT(p1, p2)
    let a = lineSegment.leftP1(radius)
    let b = lineSegment.leftP2(radius)
    let c = lineSegment.leftP1(innerRadius)
    let d = lineSegment.leftP2(innerRadius)
    let e = lineSegment.rightP1(innerRadius)
    let f = lineSegment.rightP2(innerRadius)
    let g = lineSegment.rightP1(radius)
    let h = lineSegment.rightP2(radius)
    if (clockWise !== undefined) {
      a.rotate(p1, theta, !clockWise)
      b.rotate(p2, theta, clockWise)
      c.rotate(p1, theta, !clockWise)
      d.rotate(p2, theta, clockWise)
      e.rotate(p1, theta, !clockWise)
      f.rotate(p2, theta, clockWise)
      g.rotate(p1, theta, !clockWise)
      h.rotate(p2, theta, clockWise)
    }
    let points = [a, b, c, d, e, f, g, h]
    geometry.vertices.push(...points.map(point => new THREE.Vector3(point.x, point.y, h1)))
    faces.forEach(([a, b, c, color]) => {
      const face = new THREE.Face3(length + index[a], length + index[b], length + index[c])
      face.color = new THREE.Color(color)
      geometry.faces.push(face)
    })
  }
  const addSectorFace = (geometry, { x, y }, pathAngle) => {
    const offsetAngle = Math.asin(innerRadius / ringMiddleRadius)
    const sweepAngle = Math.PI * 2 - 2 * offsetAngle
    const index = { a: 0, b: 1, c: 2, d: 3, e: 4, f: 5, g: 6 }
    const faces = [
      ['a', 'b', 'd', borderColor, true],
      ['a', 'c', 'd', borderColor, true],
      ['c', 'd', 'f', mainColor, false],
      ['c', 'e', 'f', mainColor, false],
      ['e', 'f', 'g', arrowColor, false]
    ]
    const angles = Math.ceil((Math.PI * 2) / roundFragments)
    let avg = (Math.PI * 2) / angles
    const getPoint = (angle, r) => ({ x: x + r * Math.cos(angle), y: y + r * Math.sin(angle) })
    const getACEG = angle => ({ a: getPoint(angle, ringOuterRadius), c: getPoint(angle, ringMiddleRadius), e: getPoint(angle, ringInnerRadius), g: { x, y } })
    const startAngle = pathAngle + offsetAngle
    let lastACEG = getACEG(startAngle)
    let drawBorder = true
    for (let j = 1; j <= angles; j++) {
      let length = geometry.vertices.length
      const { a, c, e, g } = lastACEG
      let angle = startAngle + j * avg
      if (angle > sweepAngle + startAngle) drawBorder = false
      const { a: b, c: d, e: f } = getACEG(angle)
      let points = [a, b, c, d, e, f, g]
      geometry.vertices.push(...points.map(point => new THREE.Vector3(point.x, point.y, h2)))
      faces.forEach(([a, b, c, color, isBorder]) => {
        if (isBorder && !drawBorder) return
        const face = new THREE.Face3(length + index[a], length + index[b], length + index[c])
        face.color = new THREE.Color(color)
        geometry.faces.push(face)
      })
      lastACEG = { a: b, c: d, e: f, g }
    }
  }
  var vercts = []
  var arrowVs = [
    [0, 0],
    [-15, -12],
    [-15, 4],
    [0, 20],
    [15, 4],
    [15, -12]
  ]
  const addArrowFace = (geometry, { x: x0, y: y0, angle }) => {
    let length = geometry.vertices.length
    const index = { a: 0, b: 1, c: 2, d: 3, e: 4, f: 5 }
    let n = angle - Math.PI / 2
    let points = arrowVs.map(([x, y]) => {
      const x1 = x * factor
      const y1 = y * factor
      return { x: x0 + x1 * Math.cos(n) - y1 * Math.sin(n), y: y0 + y1 * Math.cos(n) + x1 * Math.sin(n) }
    })
    const faces = ['abc', 'acd', 'ade', 'aef']
    points.forEach(obj => vercts.push(new THREE.Vector3(obj.x, obj.y, h2)))
    points.forEach(obj => geometry.vertices.push(new THREE.Vector3(obj.x, obj.y, h2)))
    faces.forEach(string => {
      const face = new THREE.Face3(...string.split('').map(c => length + index[c]))
      face.color = new THREE.Color(arrowColor)
      geometry.faces.push(face)
    })
  }
  if (linePath.length == 2) {
    let pointAdd = []
    pointAdd.push((parseInt(linePath[0][0]) + parseInt(linePath[1][0])) / 2)
    pointAdd.push((parseInt(linePath[0][1]) + parseInt(linePath[1][1])) / 2)
    linePath.splice(1, 0, pointAdd)
  }
  for (let i = 0; i < linePath.length - 1; i++) {
    const lineSegment = new LINESEGMENT(new POINT(...linePath[i]), new POINT(...linePath[i + 1]))
    lineSegments.push(lineSegment)
  }
  if (lineSegments.length) {
    let startLine = lineSegments[0]
    let endLine = lineSegments[lineSegments.length - 1]
    let startPathAngle = Math.atan2(startLine.y2 - startLine.y1, startLine.x2 - startLine.x1)
    let endPathAngle = Math.atan2(endLine.y1 - endLine.y2, endLine.x1 - endLine.x2)
    addSectorFace(rings, startLine.p1, startPathAngle)
    addSectorFace(rings, endLine.p2, endPathAngle)
  }
  let totalLength = avgArrow / -2
  let lastTotals = []
  let cutStraightLines = []
  let lastP2Cross = null
  for (let i = 0; i < lineSegments.length - 1; i++) {
    let lineA = lineSegments[i]
    let lineB = lineSegments[i + 1]
    let { p1Cross, p2Cross, startAngle, endAngle, circlePoint } = getRoundCornerBy3Points2({ angularPoint: lineA.p2, p1: lineA.p1, p2: lineB.p2, radius: centerRadius })
    let angleDiff = endAngle - startAngle
    const clockWise = angleDiff > Math.PI
    if (clockWise) angleDiff = Math.PI * 2 - angleDiff
    const angles = Math.ceil(angleDiff / roundFragments)
    let avg = angleDiff / angles
    let s = lastP2Cross ? lastP2Cross : lineA.p1
    let e = p1Cross
    let lineSegment = new LINESEGMENT(s, e)
    cutStraightLines.push(lineSegment)
    lastTotals.push(totalLength)
    totalLength += lineSegment.length
    addFace(roundCornoredPath, s, e)
    lastP2Cross = p2Cross
    const getFragPointByAngle = angle => ({ x: circlePoint.x + centerRadius * Math.cos(angle), y: circlePoint.y + centerRadius * Math.sin(angle) })
    let lastFragment = getFragPointByAngle(startAngle)
    for (let j = 1; j <= angles; j++) {
      let angle = startAngle + (clockWise ? -1 : 1) * j * avg
      let tmp = getFragPointByAngle(angle)
      addFace(roundCornoredPath, lastFragment, tmp, avg / 2, clockWise)
      lastFragment = tmp
    }
    if (i === lineSegments.length - 2) {
      s = p2Cross
      e = lineB.p2
      lineSegment = new LINESEGMENT(s, e)
      cutStraightLines.push(lineSegment)
      lastTotals.push(totalLength)
      totalLength += lineSegment.length
      addFace(roundCornoredPath, s, e)
    }
  }
  const num = Math.floor(totalLength / avgArrow) < 0 ? 0 : Math.floor(totalLength / avgArrow)
  new Array(num)
    .fill(0)
    .map((_, i) => i * avgArrow + avgArrow / 2)
    .map(length => {
      for (let i = 0; i < lastTotals.length; i++) {
        if (lastTotals[i] <= length && lastTotals[i] + cutStraightLines[i].length > length) return [i, (length - lastTotals[i]) / cutStraightLines[i].length]
      }
      return [lastTotals.length - 1, 1]
    })
    .map(([i, percent]) => {
      let line = cutStraightLines[i]
      return { x: (line.x2 - line.x1) * percent + line.x1, y: (line.y2 - line.y1) * percent + line.y1, angle: Math.atan2(line.y2 - line.y1, line.x2 - line.x1) }
    })
    .forEach((point, index) => {
      if (index % 3 == 0) {
        addArrowFace(arrowGeo1, point)
      } else if (index % 3 == 1) {
        addArrowFace(arrowGeo2, point)
      } else {
        addArrowFace(arrowGeo3, point)
      }
    })
  const material = new THREE.MeshBasicMaterial({ side: THREE.DoubleSide, vertexColors: THREE.FaceColors })
  const pathMesh = new THREE.Mesh(roundCornoredPath, material)
  const ringsMesh = new THREE.Mesh(rings, material)
  const arrowMesh1 = new THREE.Mesh(arrowGeo1, material)
  const arrowMesh2 = new THREE.Mesh(arrowGeo2, material)
  const arrowMesh3 = new THREE.Mesh(arrowGeo3, material)
  this.add(pathMesh)
  this.add(ringsMesh)
  this.add(arrowMesh1)
  arrowMesh2.visible = false
  this.add(arrowMesh2)
  arrowMesh3.visible = false
  this.add(arrowMesh3)
  this.name = 'meshline'
  if (!Config.overlap) {
    interVal = setInterval(() => {
      arrowMesh1.visible = false
      arrowMesh2.visible = false
      arrowMesh3.visible = false
      if (vIndex == 1) {
        arrowMesh1.visible = true
      } else if (vIndex == 2) {
        arrowMesh2.visible = true
      } else {
        arrowMesh3.visible = true
        vIndex = 0
      }
      vIndex++
    }, 200)
  }
}
PathLine.prototype = Object.create(THREE.Group.prototype)
PathLine.prototype.constructor = PathLine
PathLine.prototype.destroy = function () {
  clearInterval(interVal)
  const clearCache = item => {
    item.geometry.dispose()
    item.material.dispose()
  }
  const removeObj = obj => {
    let arr = obj.children.filter(x => x)
    arr.forEach(item => {
      if (item.children.length) {
        removeObj(item)
      } else {
        clearCache(item)
        item.clear()
      }
    })
    obj.clear()
    arr = null
  }
  removeObj(this)
}
var dijkstra = {
  single_source_shortest_paths: function (graph, s, d) {
    var predecessors = {}
    var costs = {}
    costs[s] = 0
    var open = dijkstra.PriorityQueue.make()
    open.push(s, 0)
    var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit
    while (!open.empty()) {
      closest = open.pop()
      u = closest.value
      cost_of_s_to_u = closest.cost
      adjacent_nodes = graph[u] || {}
      for (v in adjacent_nodes) {
        if (adjacent_nodes.hasOwnProperty(v)) {
          cost_of_e = adjacent_nodes[v]
          cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e
          cost_of_s_to_v = costs[v]
          first_visit = typeof costs[v] === 'undefined'
          if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
            costs[v] = cost_of_s_to_u_plus_cost_of_e
            open.push(v, cost_of_s_to_u_plus_cost_of_e)
            predecessors[v] = u
          }
        }
      }
    }
    if (typeof d !== 'undefined' && typeof costs[d] === 'undefined') {
      var msg = ['Could not find a path from ', s, ' to ', d, '.'].join('')
      throw new Error(msg)
    }
    return {
      predecessors: predecessors,
      costs: costs
    }
  },
  extract_shortest_path_from_predecessor_list: function (pred, d) {
    var nodes = []
    var u = d
    var predecessor
    while (u) {
      nodes.push(u)
      predecessor = pred.predecessors[u]
      u = pred.predecessors[u]
    }
    nodes.reverse()
    return {
      cost: pred.costs[d],
      nodes: nodes
    }
  },
  find_path: function (graph, s, d) {
    var predecessors = dijkstra.single_source_shortest_paths(graph, s, d)
    return dijkstra.extract_shortest_path_from_predecessor_list(predecessors, d)
  },
  PriorityQueue: {
    make: function (opts) {
      var T = dijkstra.PriorityQueue,
        t = {},
        key
      opts = opts || {}
      for (key in T) {
        if (T.hasOwnProperty(key)) {
          t[key] = T[key]
        }
      }
      t.queue = []
      t.sorter = opts.sorter || T.default_sorter
      return t
    },
    default_sorter: function (a, b) {
      return a.cost - b.cost
    },
    push: function (value, cost) {
      var item = {
        value: value,
        cost: cost
      }
      this.queue.push(item)
      this.queue.sort(this.sorter)
    },
    pop: function () {
      return this.queue.shift()
    },
    empty: function () {
      return this.queue.length === 0
    }
  }
}
var LZString = (function () {
  var f = String.fromCharCode
  var keyStrBase64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
  var keyStrUriSafe = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$'
  var baseReverseDic = {}

  function getBaseValue(alphabet, character) {
    if (!baseReverseDic[alphabet]) {
      baseReverseDic[alphabet] = {}
      for (var i = 0; i < alphabet.length; i++) {
        baseReverseDic[alphabet][alphabet.charAt(i)] = i
      }
    }
    return baseReverseDic[alphabet][character]
  }
  var LZString = {
    compressToBase64: function (input) {
      if (input == null) return ''
      var res = LZString._compress(input, 6, function (a) {
        return keyStrBase64.charAt(a)
      })
      switch (res.length % 4) {
        default:
        case 0:
          return res
        case 1:
          return res + '==='
        case 2:
          return res + '=='
        case 3:
          return res + '='
      }
    },
    decompressFromBase64: function (input) {
      if (input == null) return ''
      if (input == '') return null
      return LZString._decompress(input.length, 32, function (index) {
        return getBaseValue(keyStrBase64, input.charAt(index))
      })
    },
    compressToUTF16: function (input) {
      if (input == null) return ''
      return (
        LZString._compress(input, 15, function (a) {
          return f(a + 32)
        }) + ' '
      )
    },
    decompressFromUTF16: function (compressed) {
      if (compressed == null) return ''
      if (compressed == '') return null
      return LZString._decompress(compressed.length, 16384, function (index) {
        return compressed.charCodeAt(index) - 32
      })
    },
    compressToUint8Array: function (uncompressed) {
      var compressed = LZString.compress(uncompressed)
      var buf = new Uint8Array(compressed.length * 2)
      for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
        var current_value = compressed.charCodeAt(i)
        buf[i * 2] = current_value >>> 8
        buf[i * 2 + 1] = current_value % 256
      }
      return buf
    },
    decompressFromUint8Array: function (compressed) {
      if (compressed === null || compressed === undefined) {
        return LZString.decompress(compressed)
      } else {
        var buf = new Array(compressed.length / 2)
        for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) {
          buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1]
        }
        var result = []
        buf.forEach(function (c) {
          result.push(f(c))
        })
        return LZString.decompress(result.join(''))
      }
    },
    compressToEncodedURIComponent: function (input) {
      if (input == null) return ''
      return LZString._compress(input, 6, function (a) {
        return keyStrUriSafe.charAt(a)
      })
    },
    decompressFromEncodedURIComponent: function (input) {
      if (input == null) return ''
      if (input == '') return null
      input = input.replace(/ /g, '+')
      return LZString._decompress(input.length, 32, function (index) {
        return getBaseValue(keyStrUriSafe, input.charAt(index))
      })
    },
    compress: function (uncompressed) {
      return LZString._compress(uncompressed, 16, function (a) {
        return f(a)
      })
    },
    _compress: function (uncompressed, bitsPerChar, getCharFromInt) {
      if (uncompressed == null) return ''
      var i,
        value,
        context_dictionary = {},
        context_dictionaryToCreate = {},
        context_c = '',
        context_wc = '',
        context_w = '',
        context_enlargeIn = 2,
        context_dictSize = 3,
        context_numBits = 2,
        context_data = [],
        context_data_val = 0,
        context_data_position = 0,
        ii
      for (ii = 0; ii < uncompressed.length; ii += 1) {
        context_c = uncompressed.charAt(ii)
        if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
          context_dictionary[context_c] = context_dictSize++
          context_dictionaryToCreate[context_c] = true
        }
        context_wc = context_w + context_c
        if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
          context_w = context_wc
        } else {
          if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
            if (context_w.charCodeAt(0) < 256) {
              for (i = 0; i < context_numBits; i++) {
                context_data_val = context_data_val << 1
                if (context_data_position == bitsPerChar - 1) {
                  context_data_position = 0
                  context_data.push(getCharFromInt(context_data_val))
                  context_data_val = 0
                } else {
                  context_data_position++
                }
              }
              value = context_w.charCodeAt(0)
              for (i = 0; i < 8; i++) {
                context_data_val = (context_data_val << 1) | (value & 1)
                if (context_data_position == bitsPerChar - 1) {
                  context_data_position = 0
                  context_data.push(getCharFromInt(context_data_val))
                  context_data_val = 0
                } else {
                  context_data_position++
                }
                value = value >> 1
              }
            } else {
              value = 1
              for (i = 0; i < context_numBits; i++) {
                context_data_val = (context_data_val << 1) | value
                if (context_data_position == bitsPerChar - 1) {
                  context_data_position = 0
                  context_data.push(getCharFromInt(context_data_val))
                  context_data_val = 0
                } else {
                  context_data_position++
                }
                value = 0
              }
              value = context_w.charCodeAt(0)
              for (i = 0; i < 16; i++) {
                context_data_val = (context_data_val << 1) | (value & 1)
                if (context_data_position == bitsPerChar - 1) {
                  context_data_position = 0
                  context_data.push(getCharFromInt(context_data_val))
                  context_data_val = 0
                } else {
                  context_data_position++
                }
                value = value >> 1
              }
            }
            context_enlargeIn--
            if (context_enlargeIn == 0) {
              context_enlargeIn = Math.pow(2, context_numBits)
              context_numBits++
            }
            delete context_dictionaryToCreate[context_w]
          } else {
            value = context_dictionary[context_w]
            for (i = 0; i < context_numBits; i++) {
              context_data_val = (context_data_val << 1) | (value & 1)
              if (context_data_position == bitsPerChar - 1) {
                context_data_position = 0
                context_data.push(getCharFromInt(context_data_val))
                context_data_val = 0
              } else {
                context_data_position++
              }
              value = value >> 1
            }
          }
          context_enlargeIn--
          if (context_enlargeIn == 0) {
            context_enlargeIn = Math.pow(2, context_numBits)
            context_numBits++
          }
          context_dictionary[context_wc] = context_dictSize++
          context_w = String(context_c)
        }
      }
      if (context_w !== '') {
        if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
          if (context_w.charCodeAt(0) < 256) {
            for (i = 0; i < context_numBits; i++) {
              context_data_val = context_data_val << 1
              if (context_data_position == bitsPerChar - 1) {
                context_data_position = 0
                context_data.push(getCharFromInt(context_data_val))
                context_data_val = 0
              } else {
                context_data_position++
              }
            }
            value = context_w.charCodeAt(0)
            for (i = 0; i < 8; i++) {
              context_data_val = (context_data_val << 1) | (value & 1)
              if (context_data_position == bitsPerChar - 1) {
                context_data_position = 0
                context_data.push(getCharFromInt(context_data_val))
                context_data_val = 0
              } else {
                context_data_position++
              }
              value = value >> 1
            }
          } else {
            value = 1
            for (i = 0; i < context_numBits; i++) {
              context_data_val = (context_data_val << 1) | value
              if (context_data_position == bitsPerChar - 1) {
                context_data_position = 0
                context_data.push(getCharFromInt(context_data_val))
                context_data_val = 0
              } else {
                context_data_position++
              }
              value = 0
            }
            value = context_w.charCodeAt(0)
            for (i = 0; i < 16; i++) {
              context_data_val = (context_data_val << 1) | (value & 1)
              if (context_data_position == bitsPerChar - 1) {
                context_data_position = 0
                context_data.push(getCharFromInt(context_data_val))
                context_data_val = 0
              } else {
                context_data_position++
              }
              value = value >> 1
            }
          }
          context_enlargeIn--
          if (context_enlargeIn == 0) {
            context_enlargeIn = Math.pow(2, context_numBits)
            context_numBits++
          }
          delete context_dictionaryToCreate[context_w]
        } else {
          value = context_dictionary[context_w]
          for (i = 0; i < context_numBits; i++) {
            context_data_val = (context_data_val << 1) | (value & 1)
            if (context_data_position == bitsPerChar - 1) {
              context_data_position = 0
              context_data.push(getCharFromInt(context_data_val))
              context_data_val = 0
            } else {
              context_data_position++
            }
            value = value >> 1
          }
        }
        context_enlargeIn--
        if (context_enlargeIn == 0) {
          context_enlargeIn = Math.pow(2, context_numBits)
          context_numBits++
        }
      }
      value = 2
      for (i = 0; i < context_numBits; i++) {
        context_data_val = (context_data_val << 1) | (value & 1)
        if (context_data_position == bitsPerChar - 1) {
          context_data_position = 0
          context_data.push(getCharFromInt(context_data_val))
          context_data_val = 0
        } else {
          context_data_position++
        }
        value = value >> 1
      }
      while (true) {
        context_data_val = context_data_val << 1
        if (context_data_position == bitsPerChar - 1) {
          context_data.push(getCharFromInt(context_data_val))
          break
        } else context_data_position++
      }
      return context_data.join('')
    },
    decompress: function (compressed) {
      if (compressed == null) return ''
      if (compressed == '') return null
      return LZString._decompress(compressed.length, 32768, function (index) {
        return compressed.charCodeAt(index)
      })
    },
    _decompress: function (length, resetValue, getNextValue) {
      var dictionary = [],
        next,
        enlargeIn = 4,
        dictSize = 4,
        numBits = 3,
        entry = '',
        result = [],
        i,
        w,
        bits,
        resb,
        maxpower,
        power,
        c,
        data = {
          val: getNextValue(0),
          position: resetValue,
          index: 1
        }
      for (i = 0; i < 3; i += 1) {
        dictionary[i] = i
      }
      bits = 0
      maxpower = Math.pow(2, 2)
      power = 1
      while (power != maxpower) {
        resb = data.val & data.position
        data.position >>= 1
        if (data.position == 0) {
          data.position = resetValue
          data.val = getNextValue(data.index++)
        }
        bits |= (resb > 0 ? 1 : 0) * power
        power <<= 1
      }
      switch ((next = bits)) {
        case 0:
          bits = 0
          maxpower = Math.pow(2, 8)
          power = 1
          while (power != maxpower) {
            resb = data.val & data.position
            data.position >>= 1
            if (data.position == 0) {
              data.position = resetValue
              data.val = getNextValue(data.index++)
            }
            bits |= (resb > 0 ? 1 : 0) * power
            power <<= 1
          }
          c = f(bits)
          break
        case 1:
          bits = 0
          maxpower = Math.pow(2, 16)
          power = 1
          while (power != maxpower) {
            resb = data.val & data.position
            data.position >>= 1
            if (data.position == 0) {
              data.position = resetValue
              data.val = getNextValue(data.index++)
            }
            bits |= (resb > 0 ? 1 : 0) * power
            power <<= 1
          }
          c = f(bits)
          break
        case 2:
          return ''
      }
      dictionary[3] = c
      w = c
      result.push(c)
      while (true) {
        if (data.index > length) {
          return ''
        }
        bits = 0
        maxpower = Math.pow(2, numBits)
        power = 1
        while (power != maxpower) {
          resb = data.val & data.position
          data.position >>= 1
          if (data.position == 0) {
            data.position = resetValue
            data.val = getNextValue(data.index++)
          }
          bits |= (resb > 0 ? 1 : 0) * power
          power <<= 1
        }
        switch ((c = bits)) {
          case 0:
            bits = 0
            maxpower = Math.pow(2, 8)
            power = 1
            while (power != maxpower) {
              resb = data.val & data.position
              data.position >>= 1
              if (data.position == 0) {
                data.position = resetValue
                data.val = getNextValue(data.index++)
              }
              bits |= (resb > 0 ? 1 : 0) * power
              power <<= 1
            }
            dictionary[dictSize++] = f(bits)
            c = dictSize - 1
            enlargeIn--
            break
          case 1:
            bits = 0
            maxpower = Math.pow(2, 16)
            power = 1
            while (power != maxpower) {
              resb = data.val & data.position
              data.position >>= 1
              if (data.position == 0) {
                data.position = resetValue
                data.val = getNextValue(data.index++)
              }
              bits |= (resb > 0 ? 1 : 0) * power
              power <<= 1
            }
            dictionary[dictSize++] = f(bits)
            c = dictSize - 1
            enlargeIn--
            break
          case 2:
            return result.join('')
        }
        if (enlargeIn == 0) {
          enlargeIn = Math.pow(2, numBits)
          numBits++
        }
        if (dictionary[c]) {
          entry = dictionary[c]
        } else {
          if (c === dictSize) {
            entry = w + w.charAt(0)
          } else {
            return null
          }
        }
        result.push(entry)
        dictionary[dictSize++] = w + entry.charAt(0)
        enlargeIn--
        w = entry
        if (enlargeIn == 0) {
          enlargeIn = Math.pow(2, numBits)
          numBits++
        }
      }
    }
  }
  return LZString
})()
if (typeof define === 'function' && define.amd) {
  define(function () {
    return LZString
  })
} else if (typeof module !== 'undefined' && module != null) {
  module.exports = LZString
} else if (typeof angular !== 'undefined' && angular != null) {
  angular.module('LZString', []).factory('LZString', function () {
    return LZString
  })
}
////////////////////////////////---- --------------           aes   --------------------
!(function (t, n) {
  'object' == typeof exports ? (module.exports = exports = n()) : 'function' == typeof define && define.amd ? define([], n) : (t.CryptoJS = n())
})(this, function () {
  var t =
    t ||
    (function (t, n) {
      var i =
          Object.create ||
          (function () {
            function t() {}
            return function (n) {
              var i
              return (t.prototype = n), (i = new t()), (t.prototype = null), i
            }
          })(),
        e = {},
        r = (e.lib = {}),
        o = (r.Base = (function () {
          return {
            extend: function (t) {
              var n = i(this)
              return (
                t && n.mixIn(t),
                (n.hasOwnProperty('init') && this.init !== n.init) ||
                  (n.init = function () {
                    n.$super.init.apply(this, arguments)
                  }),
                (n.init.prototype = n),
                (n.$super = this),
                n
              )
            },
            create: function () {
              var t = this.extend()
              return t.init.apply(t, arguments), t
            },
            init: function () {},
            mixIn: function (t) {
              for (var n in t) t.hasOwnProperty(n) && (this[n] = t[n])
              t.hasOwnProperty('toString') && (this.toString = t.toString)
            },
            clone: function () {
              return this.init.prototype.extend(this)
            }
          }
        })()),
        s = (r.WordArray = o.extend({
          init: function (t, i) {
            ;(t = this.words = t || []), i != n ? (this.sigBytes = i) : (this.sigBytes = 4 * t.length)
          },
          toString: function (t) {
            return (t || c).stringify(this)
          },
          concat: function (t) {
            var n = this.words,
              i = t.words,
              e = this.sigBytes,
              r = t.sigBytes
            if ((this.clamp(), e % 4))
              for (var o = 0; o < r; o++) {
                var s = (i[o >>> 2] >>> (24 - (o % 4) * 8)) & 255
                n[(e + o) >>> 2] |= s << (24 - ((e + o) % 4) * 8)
              }
            else for (var o = 0; o < r; o += 4) n[(e + o) >>> 2] = i[o >>> 2]
            return (this.sigBytes += r), this
          },
          clamp: function () {
            var n = this.words,
              i = this.sigBytes
            ;(n[i >>> 2] &= 4294967295 << (32 - (i % 4) * 8)), (n.length = t.ceil(i / 4))
          },
          clone: function () {
            var t = o.clone.call(this)
            return (t.words = this.words.slice(0)), t
          },
          random: function (n) {
            for (
              var i,
                e = [],
                r = function (n) {
                  var n = n,
                    i = 987654321,
                    e = 4294967295
                  return function () {
                    ;(i = (36969 * (65535 & i) + (i >> 16)) & e), (n = (18e3 * (65535 & n) + (n >> 16)) & e)
                    var r = ((i << 16) + n) & e
                    return (r /= 4294967296), (r += 0.5), r * (t.random() > 0.5 ? 1 : -1)
                  }
                },
                o = 0;
              o < n;
              o += 4
            ) {
              var a = r(4294967296 * (i || t.random()))
              ;(i = 987654071 * a()), e.push((4294967296 * a()) | 0)
            }
            return new s.init(e, n)
          }
        })),
        a = (e.enc = {}),
        c = (a.Hex = {
          stringify: function (t) {
            for (var n = t.words, i = t.sigBytes, e = [], r = 0; r < i; r++) {
              var o = (n[r >>> 2] >>> (24 - (r % 4) * 8)) & 255
              e.push((o >>> 4).toString(16)), e.push((15 & o).toString(16))
            }
            return e.join('')
          },
          parse: function (t) {
            for (var n = t.length, i = [], e = 0; e < n; e += 2) i[e >>> 3] |= parseInt(t.substr(e, 2), 16) << (24 - (e % 8) * 4)
            return new s.init(i, n / 2)
          }
        }),
        u = (a.Latin1 = {
          stringify: function (t) {
            for (var n = t.words, i = t.sigBytes, e = [], r = 0; r < i; r++) {
              var o = (n[r >>> 2] >>> (24 - (r % 4) * 8)) & 255
              e.push(String.fromCharCode(o))
            }
            return e.join('')
          },
          parse: function (t) {
            for (var n = t.length, i = [], e = 0; e < n; e++) i[e >>> 2] |= (255 & t.charCodeAt(e)) << (24 - (e % 4) * 8)
            return new s.init(i, n)
          }
        }),
        f = (a.Utf8 = {
          stringify: function (t) {
            try {
              return decodeURIComponent(escape(u.stringify(t)))
            } catch (t) {
              throw new Error('Malformed UTF-8 data')
            }
          },
          parse: function (t) {
            return u.parse(unescape(encodeURIComponent(t)))
          }
        }),
        h = (r.BufferedBlockAlgorithm = o.extend({
          reset: function () {
            ;(this._data = new s.init()), (this._nDataBytes = 0)
          },
          _append: function (t) {
            'string' == typeof t && (t = f.parse(t)), this._data.concat(t), (this._nDataBytes += t.sigBytes)
          },
          _process: function (n) {
            var i = this._data,
              e = i.words,
              r = i.sigBytes,
              o = this.blockSize,
              a = 4 * o,
              c = r / a
            c = n ? t.ceil(c) : t.max((0 | c) - this._minBufferSize, 0)
            var u = c * o,
              f = t.min(4 * u, r)
            if (u) {
              for (var h = 0; h < u; h += o) this._doProcessBlock(e, h)
              var p = e.splice(0, u)
              i.sigBytes -= f
            }
            return new s.init(p, f)
          },
          clone: function () {
            var t = o.clone.call(this)
            return (t._data = this._data.clone()), t
          },
          _minBufferSize: 0
        })),
        p =
          ((r.Hasher = h.extend({
            cfg: o.extend(),
            init: function (t) {
              ;(this.cfg = this.cfg.extend(t)), this.reset()
            },
            reset: function () {
              h.reset.call(this), this._doReset()
            },
            update: function (t) {
              return this._append(t), this._process(), this
            },
            finalize: function (t) {
              t && this._append(t)
              var n = this._doFinalize()
              return n
            },
            blockSize: 16,
            _createHelper: function (t) {
              return function (n, i) {
                return new t.init(i).finalize(n)
              }
            },
            _createHmacHelper: function (t) {
              return function (n, i) {
                return new p.HMAC.init(t, i).finalize(n)
              }
            }
          })),
          (e.algo = {}))
      return e
    })(Math)
  return t
})
//# sourceMappingURL=core.min.js.map
!(function (e, t, i) {
  'object' == typeof exports
    ? (module.exports = exports = t(require('./core.min'), require('./sha1.min'), require('./hmac.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min', './sha1.min', './hmac.min'], t)
    : t(e.CryptoJS)
})(this, function (e) {
  return (
    (function () {
      var t = e,
        i = t.lib,
        r = i.Base,
        n = i.WordArray,
        o = t.algo,
        a = o.MD5,
        c = (o.EvpKDF = r.extend({
          cfg: r.extend({
            keySize: 4,
            hasher: a,
            iterations: 1
          }),
          init: function (e) {
            this.cfg = this.cfg.extend(e)
          },
          compute: function (e, t) {
            for (var i = this.cfg, r = i.hasher.create(), o = n.create(), a = o.words, c = i.keySize, f = i.iterations; a.length < c; ) {
              s && r.update(s)
              var s = r.update(e).finalize(t)
              r.reset()
              for (var u = 1; u < f; u++) (s = r.finalize(s)), r.reset()
              o.concat(s)
            }
            return (o.sigBytes = 4 * c), o
          }
        }))
      t.EvpKDF = function (e, t, i) {
        return c.create(i).compute(e, t)
      }
    })(),
    e.EvpKDF
  )
})
//# sourceMappingURL=evpkdf.min.js.map
!(function (r, e) {
  'object' == typeof exports
    ? (module.exports = exports = e(require('./core.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min'], e)
    : e(r.CryptoJS)
})(this, function (r) {
  return (
    (function () {
      function e(r, e, t) {
        for (var n = [], i = 0, o = 0; o < e; o++)
          if (o % 4) {
            var f = t[r.charCodeAt(o - 1)] << ((o % 4) * 2),
              c = t[r.charCodeAt(o)] >>> (6 - (o % 4) * 2)
            ;(n[i >>> 2] |= (f | c) << (24 - (i % 4) * 8)), i++
          }
        return a.create(n, i)
      }
      var t = r,
        n = t.lib,
        a = n.WordArray,
        i = t.enc
      i.Base64 = {
        stringify: function (r) {
          var e = r.words,
            t = r.sigBytes,
            n = this._map
          r.clamp()
          for (var a = [], i = 0; i < t; i += 3)
            for (
              var o = (e[i >>> 2] >>> (24 - (i % 4) * 8)) & 255,
                f = (e[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 255,
                c = (e[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 255,
                s = (o << 16) | (f << 8) | c,
                h = 0;
              h < 4 && i + 0.75 * h < t;
              h++
            )
              a.push(n.charAt((s >>> (6 * (3 - h))) & 63))
          var p = n.charAt(64)
          if (p) for (; a.length % 4; ) a.push(p)
          return a.join('')
        },
        parse: function (r) {
          var t = r.length,
            n = this._map,
            a = this._reverseMap
          if (!a) {
            a = this._reverseMap = []
            for (var i = 0; i < n.length; i++) a[n.charCodeAt(i)] = i
          }
          var o = n.charAt(64)
          if (o) {
            var f = r.indexOf(o)
            f !== -1 && (t = f)
          }
          return e(r, t, a)
        },
        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
      }
    })(),
    r.enc.Base64
  )
})
//# sourceMappingURL=enc-base64.min.js.map
!(function (e, t, r) {
  'object' == typeof exports
    ? (module.exports = exports = t(require('./core.min'), require('./evpkdf.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min', './evpkdf.min'], t)
    : t(e.CryptoJS)
})(this, function (e) {
  e.lib.Cipher ||
    (function (t) {
      var r = e,
        i = r.lib,
        n = i.Base,
        c = i.WordArray,
        o = i.BufferedBlockAlgorithm,
        s = r.enc,
        a = (s.Utf8, s.Base64),
        f = r.algo,
        p = f.EvpKDF,
        d = (i.Cipher = o.extend({
          cfg: n.extend(),
          createEncryptor: function (e, t) {
            return this.create(this._ENC_XFORM_MODE, e, t)
          },
          createDecryptor: function (e, t) {
            return this.create(this._DEC_XFORM_MODE, e, t)
          },
          init: function (e, t, r) {
            ;(this.cfg = this.cfg.extend(r)), (this._xformMode = e), (this._key = t), this.reset()
          },
          reset: function () {
            o.reset.call(this), this._doReset()
          },
          process: function (e) {
            return this._append(e), this._process()
          },
          finalize: function (e) {
            e && this._append(e)
            var t = this._doFinalize()
            return t
          },
          keySize: 4,
          ivSize: 4,
          _ENC_XFORM_MODE: 1,
          _DEC_XFORM_MODE: 2,
          _createHelper: (function () {
            function e(e) {
              return 'string' == typeof e ? B : x
            }
            return function (t) {
              return {
                encrypt: function (r, i, n) {
                  return e(i).encrypt(t, r, i, n)
                },
                decrypt: function (r, i, n) {
                  return e(i).decrypt(t, r, i, n)
                }
              }
            }
          })()
        })),
        h =
          ((i.StreamCipher = d.extend({
            _doFinalize: function () {
              var e = this._process(!0)
              return e
            },
            blockSize: 1
          })),
          (r.mode = {})),
        u = (i.BlockCipherMode = n.extend({
          createEncryptor: function (e, t) {
            return this.Encryptor.create(e, t)
          },
          createDecryptor: function (e, t) {
            return this.Decryptor.create(e, t)
          },
          init: function (e, t) {
            ;(this._cipher = e), (this._iv = t)
          }
        })),
        l = (h.CBC = (function () {
          function e(e, r, i) {
            var n = this._iv
            if (n) {
              var c = n
              this._iv = t
            } else var c = this._prevBlock
            for (var o = 0; o < i; o++) e[r + o] ^= c[o]
          }
          var r = u.extend()
          return (
            (r.Encryptor = r.extend({
              processBlock: function (t, r) {
                var i = this._cipher,
                  n = i.blockSize
                e.call(this, t, r, n), i.encryptBlock(t, r), (this._prevBlock = t.slice(r, r + n))
              }
            })),
            (r.Decryptor = r.extend({
              processBlock: function (t, r) {
                var i = this._cipher,
                  n = i.blockSize,
                  c = t.slice(r, r + n)
                i.decryptBlock(t, r), e.call(this, t, r, n), (this._prevBlock = c)
              }
            })),
            r
          )
        })()),
        _ = (r.pad = {}),
        v = (_.Pkcs7 = {
          pad: function (e, t) {
            for (var r = 4 * t, i = r - (e.sigBytes % r), n = (i << 24) | (i << 16) | (i << 8) | i, o = [], s = 0; s < i; s += 4) o.push(n)
            var a = c.create(o, i)
            e.concat(a)
          },
          unpad: function (e) {
            var t = 255 & e.words[(e.sigBytes - 1) >>> 2]
            e.sigBytes -= t
          }
        }),
        y =
          ((i.BlockCipher = d.extend({
            cfg: d.cfg.extend({
              mode: l,
              padding: v
            }),
            reset: function () {
              d.reset.call(this)
              var e = this.cfg,
                t = e.iv,
                r = e.mode
              if (this._xformMode == this._ENC_XFORM_MODE) var i = r.createEncryptor
              else {
                var i = r.createDecryptor
                this._minBufferSize = 1
              }
              this._mode && this._mode.__creator == i ? this._mode.init(this, t && t.words) : ((this._mode = i.call(r, this, t && t.words)), (this._mode.__creator = i))
            },
            _doProcessBlock: function (e, t) {
              this._mode.processBlock(e, t)
            },
            _doFinalize: function () {
              var e = this.cfg.padding
              if (this._xformMode == this._ENC_XFORM_MODE) {
                e.pad(this._data, this.blockSize)
                var t = this._process(!0)
              } else {
                var t = this._process(!0)
                e.unpad(t)
              }
              return t
            },
            blockSize: 4
          })),
          (i.CipherParams = n.extend({
            init: function (e) {
              this.mixIn(e)
            },
            toString: function (e) {
              return (e || this.formatter).stringify(this)
            }
          }))),
        m = (r.format = {}),
        k = (m.OpenSSL = {
          stringify: function (e) {
            var t = e.ciphertext,
              r = e.salt
            if (r) var i = c.create([1398893684, 1701076831]).concat(r).concat(t)
            else var i = t
            return i.toString(a)
          },
          parse: function (e) {
            var t = a.parse(e),
              r = t.words
            if (1398893684 == r[0] && 1701076831 == r[1]) {
              var i = c.create(r.slice(2, 4))
              r.splice(0, 4), (t.sigBytes -= 16)
            }
            return y.create({
              ciphertext: t,
              salt: i
            })
          }
        }),
        x = (i.SerializableCipher = n.extend({
          cfg: n.extend({
            format: k
          }),
          encrypt: function (e, t, r, i) {
            i = this.cfg.extend(i)
            var n = e.createEncryptor(r, i),
              c = n.finalize(t),
              o = n.cfg
            return y.create({
              ciphertext: c,
              key: r,
              iv: o.iv,
              algorithm: e,
              mode: o.mode,
              padding: o.padding,
              blockSize: e.blockSize,
              formatter: i.format
            })
          },
          decrypt: function (e, t, r, i) {
            ;(i = this.cfg.extend(i)), (t = this._parse(t, i.format))
            var n = e.createDecryptor(r, i).finalize(t.ciphertext)
            return n
          },
          _parse: function (e, t) {
            return 'string' == typeof e ? t.parse(e, this) : e
          }
        })),
        g = (r.kdf = {}),
        S = (g.OpenSSL = {
          execute: function (e, t, r, i) {
            i || (i = c.random(8))
            var n = p
                .create({
                  keySize: t + r
                })
                .compute(e, i),
              o = c.create(n.words.slice(t), 4 * r)
            return (
              (n.sigBytes = 4 * t),
              y.create({
                key: n,
                iv: o,
                salt: i
              })
            )
          }
        }),
        B = (i.PasswordBasedCipher = x.extend({
          cfg: x.cfg.extend({
            kdf: S
          }),
          encrypt: function (e, t, r, i) {
            i = this.cfg.extend(i)
            var n = i.kdf.execute(r, e.keySize, e.ivSize)
            i.iv = n.iv
            var c = x.encrypt.call(this, e, t, n.key, i)
            return c.mixIn(n), c
          },
          decrypt: function (e, t, r, i) {
            ;(i = this.cfg.extend(i)), (t = this._parse(t, i.format))
            var n = i.kdf.execute(r, e.keySize, e.ivSize, t.salt)
            i.iv = n.iv
            var c = x.decrypt.call(this, e, t, n.key, i)
            return c
          }
        }))
    })()
})
//# sourceMappingURL=cipher-core.min.js.map
!(function (e, i) {
  'object' == typeof exports
    ? (module.exports = exports = i(require('./core.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min'], i)
    : i(e.CryptoJS)
})(this, function (e) {
  !(function () {
    var i = e,
      t = i.lib,
      n = t.Base,
      s = i.enc,
      r = s.Utf8,
      o = i.algo
    o.HMAC = n.extend({
      init: function (e, i) {
        ;(e = this._hasher = new e.init()), 'string' == typeof i && (i = r.parse(i))
        var t = e.blockSize,
          n = 4 * t
        i.sigBytes > n && (i = e.finalize(i)), i.clamp()
        for (var s = (this._oKey = i.clone()), o = (this._iKey = i.clone()), a = s.words, f = o.words, c = 0; c < t; c++) (a[c] ^= 1549556828), (f[c] ^= 909522486)
        ;(s.sigBytes = o.sigBytes = n), this.reset()
      },
      reset: function () {
        var e = this._hasher
        e.reset(), e.update(this._iKey)
      },
      update: function (e) {
        return this._hasher.update(e), this
      },
      finalize: function (e) {
        var i = this._hasher,
          t = i.finalize(e)
        i.reset()
        var n = i.finalize(this._oKey.clone().concat(t))
        return n
      }
    })
  })()
})
//# sourceMappingURL=hmac.min.js.map
!(function (e, o, r) {
  'object' == typeof exports
    ? (module.exports = exports = o(require('./core.min'), require('./cipher-core.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min', './cipher-core.min'], o)
    : o(e.CryptoJS)
})(this, function (e) {
  return (
    (e.mode.ECB = (function () {
      var o = e.lib.BlockCipherMode.extend()
      return (
        (o.Encryptor = o.extend({
          processBlock: function (e, o) {
            this._cipher.encryptBlock(e, o)
          }
        })),
        (o.Decryptor = o.extend({
          processBlock: function (e, o) {
            this._cipher.decryptBlock(e, o)
          }
        })),
        o
      )
    })()),
    e.mode.ECB
  )
})
//# sourceMappingURL=mode-ecb.min.js.map
!(function (e, r, i) {
  'object' == typeof exports
    ? (module.exports = exports = r(require('./core.min'), require('./cipher-core.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min', './cipher-core.min'], r)
    : r(e.CryptoJS)
})(this, function (e) {
  return e.pad.Pkcs7
})
//# sourceMappingURL=pad-pkcs7.min.js.map
!(function (e, r, i) {
  'object' == typeof exports
    ? (module.exports = exports = r(require('./core.min'), require('./enc-base64.min'), require('./md5.min'), require('./evpkdf.min'), require('./cipher-core.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min', './enc-base64.min', './md5.min', './evpkdf.min', './cipher-core.min'], r)
    : r(e.CryptoJS)
})(this, function (e) {
  return (
    (function () {
      var r = e,
        i = r.lib,
        n = i.BlockCipher,
        o = r.algo,
        t = [],
        c = [],
        s = [],
        f = [],
        a = [],
        d = [],
        u = [],
        v = [],
        h = [],
        y = []
      !(function () {
        for (var e = [], r = 0; r < 256; r++) r < 128 ? (e[r] = r << 1) : (e[r] = (r << 1) ^ 283)
        for (var i = 0, n = 0, r = 0; r < 256; r++) {
          var o = n ^ (n << 1) ^ (n << 2) ^ (n << 3) ^ (n << 4)
          ;(o = (o >>> 8) ^ (255 & o) ^ 99), (t[i] = o), (c[o] = i)
          var p = e[i],
            l = e[p],
            _ = e[l],
            k = (257 * e[o]) ^ (16843008 * o)
          ;(s[i] = (k << 24) | (k >>> 8)), (f[i] = (k << 16) | (k >>> 16)), (a[i] = (k << 8) | (k >>> 24)), (d[i] = k)
          var k = (16843009 * _) ^ (65537 * l) ^ (257 * p) ^ (16843008 * i)
          ;(u[o] = (k << 24) | (k >>> 8)),
            (v[o] = (k << 16) | (k >>> 16)),
            (h[o] = (k << 8) | (k >>> 24)),
            (y[o] = k),
            i ? ((i = p ^ e[e[e[_ ^ p]]]), (n ^= e[e[n]])) : (i = n = 1)
        }
      })()
      var p = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54],
        l = (o.AES = n.extend({
          _doReset: function () {
            if (!this._nRounds || this._keyPriorReset !== this._key) {
              for (
                var e = (this._keyPriorReset = this._key),
                  r = e.words,
                  i = e.sigBytes / 4,
                  n = (this._nRounds = i + 6),
                  o = 4 * (n + 1),
                  c = (this._keySchedule = []),
                  s = 0;
                s < o;
                s++
              )
                if (s < i) c[s] = r[s]
                else {
                  var f = c[s - 1]
                  s % i
                    ? i > 6 && s % i == 4 && (f = (t[f >>> 24] << 24) | (t[(f >>> 16) & 255] << 16) | (t[(f >>> 8) & 255] << 8) | t[255 & f])
                    : ((f = (f << 8) | (f >>> 24)),
                      (f = (t[f >>> 24] << 24) | (t[(f >>> 16) & 255] << 16) | (t[(f >>> 8) & 255] << 8) | t[255 & f]),
                      (f ^= p[(s / i) | 0] << 24)),
                    (c[s] = c[s - i] ^ f)
                }
              for (var a = (this._invKeySchedule = []), d = 0; d < o; d++) {
                var s = o - d
                if (d % 4) var f = c[s]
                else var f = c[s - 4]
                d < 4 || s <= 4 ? (a[d] = f) : (a[d] = u[t[f >>> 24]] ^ v[t[(f >>> 16) & 255]] ^ h[t[(f >>> 8) & 255]] ^ y[t[255 & f]])
              }
            }
          },
          encryptBlock: function (e, r) {
            this._doCryptBlock(e, r, this._keySchedule, s, f, a, d, t)
          },
          decryptBlock: function (e, r) {
            var i = e[r + 1]
            ;(e[r + 1] = e[r + 3]), (e[r + 3] = i), this._doCryptBlock(e, r, this._invKeySchedule, u, v, h, y, c)
            var i = e[r + 1]
            ;(e[r + 1] = e[r + 3]), (e[r + 3] = i)
          },
          _doCryptBlock: function (e, r, i, n, o, t, c, s) {
            for (var f = this._nRounds, a = e[r] ^ i[0], d = e[r + 1] ^ i[1], u = e[r + 2] ^ i[2], v = e[r + 3] ^ i[3], h = 4, y = 1; y < f; y++) {
              var p = n[a >>> 24] ^ o[(d >>> 16) & 255] ^ t[(u >>> 8) & 255] ^ c[255 & v] ^ i[h++],
                l = n[d >>> 24] ^ o[(u >>> 16) & 255] ^ t[(v >>> 8) & 255] ^ c[255 & a] ^ i[h++],
                _ = n[u >>> 24] ^ o[(v >>> 16) & 255] ^ t[(a >>> 8) & 255] ^ c[255 & d] ^ i[h++],
                k = n[v >>> 24] ^ o[(a >>> 16) & 255] ^ t[(d >>> 8) & 255] ^ c[255 & u] ^ i[h++]
              ;(a = p), (d = l), (u = _), (v = k)
            }
            var p = ((s[a >>> 24] << 24) | (s[(d >>> 16) & 255] << 16) | (s[(u >>> 8) & 255] << 8) | s[255 & v]) ^ i[h++],
              l = ((s[d >>> 24] << 24) | (s[(u >>> 16) & 255] << 16) | (s[(v >>> 8) & 255] << 8) | s[255 & a]) ^ i[h++],
              _ = ((s[u >>> 24] << 24) | (s[(v >>> 16) & 255] << 16) | (s[(a >>> 8) & 255] << 8) | s[255 & d]) ^ i[h++],
              k = ((s[v >>> 24] << 24) | (s[(a >>> 16) & 255] << 16) | (s[(d >>> 8) & 255] << 8) | s[255 & u]) ^ i[h++]
            ;(e[r] = p), (e[r + 1] = l), (e[r + 2] = _), (e[r + 3] = k)
          },
          keySize: 8
        }))
      r.AES = n._createHelper(l)
    })(),
    e.AES
  )
})
//# sourceMappingURL=aes.min.js.map
!(function (e, n) {
  'object' == typeof exports
    ? (module.exports = exports = n(require('./core.min')))
    : 'function' == typeof define && define.amd
    ? define(['./core.min'], n)
    : n(e.CryptoJS)
})(this, function (e) {
  return e.enc.Utf8
})
////////////////////////-------LineSegmentsGeometry----------------------
THREE.LineSegmentsGeometry = function () {
  THREE.InstancedBufferGeometry.call(this)
  this.type = 'LineSegmentsGeometry'
  var plane = new THREE.BufferGeometry()
  var 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]
  var uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2]
  var index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5]
  this.setIndex(index)
  this.addAttribute('position', new THREE.Float32BufferAttribute(positions, 3))
  this.addAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2))
}
THREE.LineSegmentsGeometry.prototype = Object.assign(Object.create(THREE.InstancedBufferGeometry.prototype), {
  constructor: THREE.LineSegmentsGeometry,
  isLineSegmentsGeometry: true,
  applyMatrix: function (matrix) {
    var start = this.attributes.instanceStart
    var end = this.attributes.instanceEnd
    if (start !== undefined) {
      matrix.applyToBufferAttribute(start)
      matrix.applyToBufferAttribute(end)
      start.data.needsUpdate = true
    }
    if (this.boundingBox !== null) {
      this.computeBoundingBox()
    }
    if (this.boundingSphere !== null) {
      this.computeBoundingSphere()
    }
    return this
  },
  setPositions: function (array) {
    var lineSegments
    if (array instanceof Float32Array) {
      lineSegments = array
    } else if (Array.isArray(array)) {
      lineSegments = new Float32Array(array)
    }
    var instanceBuffer = new THREE.InstancedInterleavedBuffer(lineSegments, 6, 1) // xyz, xyz
    this.addAttribute('instanceStart', new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 0)) // xyz
    this.addAttribute('instanceEnd', new THREE.InterleavedBufferAttribute(instanceBuffer, 3, 3)) // xyz
    //
    this.computeBoundingBox()
    this.computeBoundingSphere()
    return this
  },
  setColors: function (array) {
    var colors
    if (array instanceof Float32Array) {
      colors = array
    } else if (Array.isArray(array)) {
      colors = new Float32Array(array)
    }
    var instanceColorBuffer = new THREE.InstancedInterleavedBuffer(colors, 6, 1) // rgb, rgb
    this.addAttribute('instanceColorStart', new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 0)) // rgb
    this.addAttribute('instanceColorEnd', new THREE.InterleavedBufferAttribute(instanceColorBuffer, 3, 3)) // rgb
    return this
  },
  fromWireframeGeometry: function (geometry) {
    this.setPositions(geometry.attributes.position.array)
    return this
  },
  fromEdgesGeometry: function (geometry) {
    this.setPositions(geometry.attributes.position.array)
    return this
  },
  fromMesh: function (mesh) {
    this.fromWireframeGeometry(new THREE.WireframeGeometry(mesh.geometry))
    // set colors, maybe
    return this
  },

  fromLineSegements: function (lineSegments) {
    var geometry = lineSegments.geometry
    if (geometry.isGeometry) {
      this.setPositions(geometry.vertices)
    } else if (geometry.isBufferGeometry) {
      this.setPositions(geometry.position.array) // assumes non-indexed
    }
    // set colors, maybe
    return this
  },
  computeBoundingBox: (function () {
    var box = new THREE.Box3()
    return function computeBoundingBox() {
      if (this.boundingBox === null) {
        this.boundingBox = new THREE.Box3()
      }
      var start = this.attributes.instanceStart
      var end = this.attributes.instanceEnd
      if (start !== undefined && end !== undefined) {
        this.boundingBox.setFromBufferAttribute(start)
        box.setFromBufferAttribute(end)
        this.boundingBox.union(box)
      }
    }
  })(),
  computeBoundingSphere: (function () {
    var vector = new THREE.Vector3()
    return function computeBoundingSphere() {
      if (this.boundingSphere === null) {
        this.boundingSphere = new THREE.Sphere()
      }
      if (this.boundingBox === null) {
        this.computeBoundingBox()
      }
      var start = this.attributes.instanceStart
      var end = this.attributes.instanceEnd
      if (start !== undefined && end !== undefined) {
        var center = this.boundingSphere.center
        this.boundingBox.getCenter(center)
        var maxRadiusSq = 0
        for (var i = 0, il = start.count; i < il; i++) {
          vector.fromBufferAttribute(start, i)
          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector))
          vector.fromBufferAttribute(end, i)
          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(vector))
        }
        this.boundingSphere.radius = Math.sqrt(maxRadiusSq)
      }
    }
  })(),
  toJSON: function () {
    // todo
  },
  clone: function () {
    // todo
  },
  copy: function (source) {
    // todo
    return this
  }
})
//////////////////////////////---------------LineMaterial-----------
THREE.UniformsLib.line = {
  linewidth: { value: 1 },
  resolution: { value: new THREE.Vector2(1, 1) },
  dashScale: { value: 1 },
  dashSize: { value: 1 },
  gapSize: { value: 1 } // todo FIX - maybe change to totalSize
}
THREE.ShaderLib['line'] = {
  uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib.common, THREE.UniformsLib.fog, THREE.UniformsLib.line]),
  vertexShader: `
		#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;

		varying vec2 vUv;

		#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;

			#endif

			float aspect = resolution.x / resolution.y;

			vUv = uv;

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

			// 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
			vec2 ndcStart = clipStart.xy / clipStart.w;
			vec2 ndcEnd = clipEnd.xy / clipEnd.w;

			// direction
			vec2 dir = ndcEnd - ndcStart;

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

			// perpendicular to dir
			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;

			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: `
		uniform vec3 diffuse;
		uniform float opacity;

		#ifdef USE_DASH

			uniform float dashSize;
			uniform float gapSize;

		#endif

		varying float vLineDistance;

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

		varying vec2 vUv;

		void main() {

			#include <clipping_planes_fragment>

			#ifdef USE_DASH

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

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

			#endif

			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;

			}

			vec4 diffuseColor = vec4( diffuse, opacity );

			#include <logdepthbuf_fragment>
			#include <color_fragment>

			gl_FragColor = vec4( diffuseColor.rgb, diffuseColor.a );

			#include <premultiplied_alpha_fragment>
			#include <tonemapping_fragment>
			#include <encodings_fragment>
			#include <fog_fragment>

		}	`
}

THREE.LineMaterial = function (parameters) {
  THREE.ShaderMaterial.call(this, {
    type: 'LineMaterial',
    uniforms: THREE.UniformsUtils.clone(THREE.ShaderLib['line'].uniforms),
    vertexShader: THREE.ShaderLib['line'].vertexShader,
    fragmentShader: THREE.ShaderLib['line'].fragmentShader
  })
  this.dashed = false
  Object.defineProperties(this, {
    color: {
      enumerable: true,
      get: function () {
        return this.uniforms.diffuse.value
      },
      set: function (value) {
        this.uniforms.diffuse.value = value
      }
    },
    linewidth: {
      enumerable: true,
      get: function () {
        return this.uniforms.linewidth.value
      },
      set: function (value) {
        this.uniforms.linewidth.value = value
      }
    },
    dashScale: {
      enumerable: true,
      get: function () {
        return this.uniforms.dashScale.value
      },
      set: function (value) {
        this.uniforms.dashScale.value = value
      }
    },
    dashSize: {
      enumerable: true,
      get: function () {
        return this.uniforms.dashSize.value
      },
      set: function (value) {
        this.uniforms.dashSize.value = value
      }
    },
    gapSize: {
      enumerable: true,
      get: function () {
        return this.uniforms.gapSize.value
      },
      set: function (value) {
        this.uniforms.gapSize.value = value
      }
    },
    resolution: {
      enumerable: true,
      get: function () {
        return this.uniforms.resolution.value
      },
      set: function (value) {
        this.uniforms.resolution.value.copy(value)
      }
    }
  })
  this.setValues(parameters)
}
THREE.LineMaterial.prototype = Object.create(THREE.ShaderMaterial.prototype)
THREE.LineMaterial.prototype.constructor = THREE.LineMaterial
THREE.LineMaterial.prototype.isLineMaterial = true
THREE.LineMaterial.prototype.copy = function (source) {
  THREE.ShaderMaterial.prototype.copy.call(this, source)
  this.color.copy(source.color)
  this.linewidth = source.linewidth
  this.resolution = source.resolution
  // todo
  return this
}
//////////////////////////// ----------  LineGeometry  --------------
THREE.LineGeometry = function () {
  THREE.LineSegmentsGeometry.call(this)
  this.type = 'LineGeometry'
}
THREE.LineGeometry.prototype = Object.assign(Object.create(THREE.LineSegmentsGeometry.prototype), {
  constructor: THREE.LineGeometry,
  isLineGeometry: true,
  setPositions: function (array) {
    // converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
    var length = array.length - 3
    var points = new Float32Array(2 * length)
    for (var 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]
    }
    THREE.LineSegmentsGeometry.prototype.setPositions.call(this, points)
    return this
  },
  setColors: function (array) {
    // converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
    var length = array.length - 3
    var colors = new Float32Array(2 * length)
    for (var 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]
    }
    THREE.LineSegmentsGeometry.prototype.setColors.call(this, colors)
    return this
  },
  fromLine: function (line) {
    var geometry = line.geometry
    if (geometry.isGeometry) {
      this.setPositions(geometry.vertices)
    } else if (geometry.isBufferGeometry) {
      this.setPositions(geometry.position.array) // assumes non-indexed
    }
    // set colors, maybe
    return this
  },
  copy: function (source) {
    // todo
    return this
  }
})