@luxonis/visualizer-protobuf 2.68.10 → 2.68.12

package/dist/{FoxgloveServer-VUfAN9DL.js → FoxgloveServer-h5m-pXp3.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './protobuf-CUXoOgMk.js';
+import { g as getDefaultExportFromCjs } from './protobuf-BFCtaU7c.js';
 import require$$0 from 'ms';
 
 var eventemitter3 = {exports: {}};

package/dist/{WorkerImageDecoder.worker-B8iTthbG.js → WorkerImageDecoder.worker-CzdrgEQs.js}

@@ -1,6 +1,6 @@
-import { d as decodeRawImage } from './decodeImage-DAWmFdMI.js';
-import './i18next-IYI3-Nuv.js';
-import './isArrayLikeObject-Bytw9p-q.js';
+import { d as decodeRawImage } from './decodeImage-CknL-EpW.js';
+import './i18next-CVtg8K02.js';
+import './isArrayLikeObject-D6CeGPwa.js';
 
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v2.0. If a copy of the MPL was not distributed with this

package/dist/{communicator-CuoUie5N.js → communicator-Ch92rcoU.js}

@@ -1,4 +1,4 @@
-import { p as protobufsBySchema } from './protobuf-CUXoOgMk.js';
+import { p as protobufsBySchema } from './protobuf-BFCtaU7c.js';
 import { r as recordToDataView } from './encoding-DqlhpFR2.js';
 
 // This Source Code Form is subject to the terms of the Mozilla Public

package/dist/{decodeImage-DAWmFdMI.js → decodeImage-CknL-EpW.js}

@@ -1,4 +1,556 @@
-import { t as tinycolor, n as t, m as merge } from './i18next-IYI3-Nuv.js';
+import { b as baseAssignValue, a as assignValue, t as tinycolor, c as t } from './i18next-CVtg8K02.js';
+import { h as isObject, c as isArrayLike, j as isIndex, u as eq, b as baseRest, g as isPrototype, p as arrayLikeKeys, n as overArg, k as isObjectLike, l as baseGetTag, r as root, U as Uint8Array$1, d as isBuffer, e as isTypedArray$1, i as isArray, a as isArrayLikeObject, f as isArguments, C as isFunction, y as baseFor, v as Stack } from './isArrayLikeObject-D6CeGPwa.js';
+
+/** Built-in value references. */
+var objectCreate = Object.create;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+  function object() {}
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object;
+    object.prototype = undefined;
+    return result;
+  };
+}());
+
+/**
+ * Copies the values of `source` to `array`.
+ *
+ * @private
+ * @param {Array} source The array to copy values from.
+ * @param {Array} [array=[]] The array to copy values to.
+ * @returns {Array} Returns `array`.
+ */
+function copyArray$1(source, array) {
+  var index = -1,
+      length = source.length;
+
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+
+/**
+ * Copies properties of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy properties from.
+ * @param {Array} props The property identifiers to copy.
+ * @param {Object} [object={}] The object to copy properties to.
+ * @param {Function} [customizer] The function to customize copied values.
+ * @returns {Object} Returns `object`.
+ */
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+
+  var index = -1,
+      length = props.length;
+
+  while (++index < length) {
+    var key = props[index];
+
+    var newValue = undefined;
+
+    if (newValue === undefined) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+
+/**
+ * Checks if the given arguments are from an iteratee call.
+ *
+ * @private
+ * @param {*} value The potential iteratee value argument.
+ * @param {*} index The potential iteratee index or key argument.
+ * @param {*} object The potential iteratee object argument.
+ * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+ *  else `false`.
+ */
+function isIterateeCall(value, index, object) {
+  if (!isObject(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == 'number'
+        ? (isArrayLike(object) && isIndex(index, object.length))
+        : (type == 'string' && index in object)
+      ) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+
+/**
+ * Creates a function like `_.assign`.
+ *
+ * @private
+ * @param {Function} assigner The function to assign values.
+ * @returns {Function} Returns the new assigner function.
+ */
+function createAssigner(assigner) {
+  return baseRest(function(object, sources) {
+    var index = -1,
+        length = sources.length,
+        customizer = length > 1 ? sources[length - 1] : undefined,
+        guard = length > 2 ? sources[2] : undefined;
+
+    customizer = (assigner.length > 3 && typeof customizer == 'function')
+      ? (length--, customizer)
+      : undefined;
+
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+      customizer = length < 3 ? undefined : customizer;
+      length = 1;
+    }
+    object = Object(object);
+    while (++index < length) {
+      var source = sources[index];
+      if (source) {
+        assigner(object, source, index, customizer);
+      }
+    }
+    return object;
+  });
+}
+
+/**
+ * This function is like
+ * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * except that it includes inherited enumerable properties.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/**
+ * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ */
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object),
+      result = [];
+
+  for (var key in object) {
+    if (!(key == 'constructor' && (isProto || !hasOwnProperty$1.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */
+function keysIn(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+    funcToString.call(Ctor) == objectCtorString;
+}
+
+/** Detect free variable `exports`. */
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+/** Detect free variable `module`. */
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+/** Detect the popular CommonJS extension `module.exports`. */
+var moduleExports = freeModule && freeModule.exports === freeExports;
+
+/** Built-in value references. */
+var Buffer = moduleExports ? root.Buffer : undefined,
+    allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;
+
+/**
+ * Creates a clone of  `buffer`.
+ *
+ * @private
+ * @param {Buffer} buffer The buffer to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Buffer} Returns the cloned buffer.
+ */
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length,
+      result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+
+  buffer.copy(result);
+  return result;
+}
+
+/**
+ * Creates a clone of `arrayBuffer`.
+ *
+ * @private
+ * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+ * @returns {ArrayBuffer} Returns the cloned array buffer.
+ */
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array$1(result).set(new Uint8Array$1(arrayBuffer));
+  return result;
+}
+
+/**
+ * Creates a clone of `typedArray`.
+ *
+ * @private
+ * @param {Object} typedArray The typed array to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned typed array.
+ */
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+
+/**
+ * Initializes an object clone.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneObject(object) {
+  return (typeof object.constructor == 'function' && !isPrototype(object))
+    ? baseCreate(getPrototype(object))
+    : {};
+}
+
+/**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignMergeValue(object, key, value) {
+  if ((value !== undefined && !eq(object[key], value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+/**
+ * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function safeGet(object, key) {
+  if (key === 'constructor' && typeof object[key] === 'function') {
+    return;
+  }
+
+  if (key == '__proto__') {
+    return;
+  }
+
+  return object[key];
+}
+
+/**
+ * Converts `value` to a plain object flattening inherited enumerable string
+ * keyed properties of `value` to own properties of the plain object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Object} Returns the converted plain object.
+ * @example
+ *
+ * function Foo() {
+ *   this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.assign({ 'a': 1 }, new Foo);
+ * // => { 'a': 1, 'b': 2 }
+ *
+ * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+ * // => { 'a': 1, 'b': 2, 'c': 3 }
+ */
+function toPlainObject(value) {
+  return copyObject(value, keysIn(value));
+}
+
+/**
+ * A specialized version of `baseMerge` for arrays and objects which performs
+ * deep merges and tracks traversed objects enabling objects with circular
+ * references to be merged.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {string} key The key of the value to merge.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} mergeFunc The function to merge values.
+ * @param {Function} [customizer] The function to customize assigned values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet(object, key),
+      srcValue = safeGet(source, key),
+      stacked = stack.get(srcValue);
+
+  if (stacked) {
+    assignMergeValue(object, key, stacked);
+    return;
+  }
+  var newValue = customizer
+    ? customizer(objValue, srcValue, (key + ''), object, source, stack)
+    : undefined;
+
+  var isCommon = newValue === undefined;
+
+  if (isCommon) {
+    var isArr = isArray(srcValue),
+        isBuff = !isArr && isBuffer(srcValue),
+        isTyped = !isArr && !isBuff && isTypedArray$1(srcValue);
+
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray(objValue)) {
+        newValue = objValue;
+      }
+      else if (isArrayLikeObject(objValue)) {
+        newValue = copyArray$1(objValue);
+      }
+      else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer(srcValue, true);
+      }
+      else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray(srcValue, true);
+      }
+      else {
+        newValue = [];
+      }
+    }
+    else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+      newValue = objValue;
+      if (isArguments(objValue)) {
+        newValue = toPlainObject(objValue);
+      }
+      else if (!isObject(objValue) || isFunction(objValue)) {
+        newValue = initCloneObject(srcValue);
+      }
+    }
+    else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    // Recursively merge objects and arrays (susceptible to call stack limits).
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack['delete'](srcValue);
+  }
+  assignMergeValue(object, key, newValue);
+}
+
+/**
+ * The base implementation of `_.merge` without support for multiple sources.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @param {number} srcIndex The index of `source`.
+ * @param {Function} [customizer] The function to customize merged values.
+ * @param {Object} [stack] Tracks traversed source values and their merged
+ *  counterparts.
+ */
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack);
+    if (isObject(srcValue)) {
+      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+    }
+    else {
+      var newValue = customizer
+        ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
+        : undefined;
+
+      if (newValue === undefined) {
+        newValue = srcValue;
+      }
+      assignMergeValue(object, key, newValue);
+    }
+  }, keysIn);
+}
+
+/**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ *   'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ *   'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */
+var merge = createAssigner(function(object, source, srcIndex) {
+  baseMerge(object, source, srcIndex);
+});
 
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v2.0. If a copy of the MPL was not distributed with this
@@ -53002,4 +53554,4 @@ async function decodeRawImage(image, options, output) {
   }
 }
 
-export { Loader as $, rgbaToLinear as A, Box3 as B, Color as C, DoubleSide as D, RedFormat as E, Float32BufferAttribute as F, RGBAFormat as G, getColorConverter as H, InstancedBufferGeometry as I, FloatType as J, UnsignedByteType as K, Line3 as L, Matrix4 as M, NotEqualStencilFunc as N, Object3D as O, PointsMaterial as P, NEEDS_MIN_MAX as Q, ReplaceStencilOp as R, Sphere as S, InstancedMesh as T, UniformsLib as U, Vector3 as V, WireframeGeometry as W, CylinderGeometry as X, ConeGeometry as Y, DataTextureLoader as Z, LinearMipmapLinearFilter as _, InstancedInterleavedBuffer as a, StaticDrawUsage as a$, LoaderUtils as a0, FileLoader as a1, MeshBasicMaterial as a2, Scene as a3, TextureLoader as a4, AnimationClip as a5, VectorKeyframeTrack as a6, QuaternionKeyframeTrack as a7, MeshLambertMaterial as a8, MeshPhongMaterial as a9, LineLoop as aA, Points as aB, InterpolateLinear as aC, ColorManagement as aD, NearestMipmapNearestFilter as aE, LinearMipmapNearestFilter as aF, NearestMipmapLinearFilter as aG, MirroredRepeatWrapping as aH, InterpolateDiscrete as aI, Texture as aJ, NumberKeyframeTrack as aK, Interpolant as aL, EdgesGeometry as aM, LoadingManager as aN, stringToRgb as aO, getLuminance as aP, Euler as aQ, vec3TupleApproxEquals as aR, decodeCompressedImageToBitmap as aS, CanvasTexture as aT, Shape as aU, SRGBToLinear as aV, ShapeGeometry as aW, DynamicDrawUsage as aX, ShaderChunk as aY, IMAGE_DEFAULT_COLOR_MODE_SETTINGS as aZ, colorHasTransparency as a_, FrontSide as aa, PerspectiveCamera as ab, OrthographicCamera as ac, AmbientLight as ad, SpotLight as ae, PointLight as af, DirectionalLight as ag, BufferGeometry as ah, Group as ai, Quaternion as aj, Bone as ak, LineBasicMaterial as al, SkinnedMesh as am, Line as an, LineSegments as ao, RepeatWrapping as ap, Skeleton as aq, BufferAttribute as ar, TrianglesDrawMode as as, TriangleFanDrawMode as at, TriangleStripDrawMode as au, MeshPhysicalMaterial as av, ImageBitmapLoader as aw, InterleavedBuffer as ax, Material as ay, PropertyBinding as az, InterleavedBufferAttribute as b, RawShaderMaterial as b0, GLSL3 as b1, colorFieldComputedPrefix as b2, getRotationTo as b3, SphereGeometry as b4, rgbaGradient as b5, InstancedBufferAttribute as b6, BoxGeometry as b7, DARK_OUTLINE as b8, LIGHT_OUTLINE as b9, CircleGeometry as ba, LineDashedMaterial as bb, GreaterDepth as bc, EventDispatcher as bd, Plane as be, Raycaster as bf, WebGLRenderTarget as bg, THREE as bh, Spherical as bi, WebGLRenderer as bj, NoToneMapping as bk, VSMShadowMap as bl, HemisphereLight as bm, Vector2 as c, decodeRawImage as d, ShaderLib as e, UniformsUtils as f, ShaderMaterial as g, Vector4 as h, Mesh as i, MathUtils as j, MeshStandardMaterial as k, rgbaToCssString as l, makeRgba as m, colorModeSettingsFields as n, autoSelectColorSettings as o, PlaneGeometry as p, DataTexture as q, rgbToThreeColor as r, stringToRgba as s, UVMapping as t, ClampToEdgeWrapping as u, NearestFilter as v, LinearFilter as w, FS_SRGB_TO_LINEAR as x, SRGBColorSpace as y, LinearSRGBColorSpace as z };
+export { getColorConverter as $, PlaneGeometry as A, Box3 as B, Color as C, DoubleSide as D, DataTexture as E, Float32BufferAttribute as F, UVMapping as G, ClampToEdgeWrapping as H, InstancedBufferGeometry as I, NearestFilter as J, LinearFilter as K, Line3 as L, Matrix4 as M, NotEqualStencilFunc as N, Object3D as O, PointsMaterial as P, FS_SRGB_TO_LINEAR as Q, ReplaceStencilOp as R, Sphere as S, SRGBColorSpace as T, UniformsLib as U, Vector3 as V, WireframeGeometry as W, LinearSRGBColorSpace as X, rgbaToLinear as Y, RedFormat as Z, RGBAFormat as _, cloneArrayBuffer as a, decodeCompressedImageToBitmap as a$, FloatType as a0, UnsignedByteType as a1, NEEDS_MIN_MAX as a2, InstancedMesh as a3, CylinderGeometry as a4, ConeGeometry as a5, DataTextureLoader as a6, LinearMipmapLinearFilter as a7, Loader as a8, LoaderUtils as a9, BufferAttribute as aA, TrianglesDrawMode as aB, TriangleFanDrawMode as aC, TriangleStripDrawMode as aD, MeshPhysicalMaterial as aE, ImageBitmapLoader as aF, InterleavedBuffer as aG, Material as aH, PropertyBinding as aI, LineLoop as aJ, Points as aK, InterpolateLinear as aL, ColorManagement as aM, NearestMipmapNearestFilter as aN, LinearMipmapNearestFilter as aO, NearestMipmapLinearFilter as aP, MirroredRepeatWrapping as aQ, InterpolateDiscrete as aR, Texture as aS, NumberKeyframeTrack as aT, Interpolant as aU, EdgesGeometry as aV, LoadingManager as aW, stringToRgb as aX, getLuminance as aY, Euler as aZ, vec3TupleApproxEquals as a_, FileLoader as aa, MeshBasicMaterial as ab, Scene as ac, TextureLoader as ad, AnimationClip as ae, VectorKeyframeTrack as af, QuaternionKeyframeTrack as ag, MeshLambertMaterial as ah, MeshPhongMaterial as ai, FrontSide as aj, PerspectiveCamera as ak, OrthographicCamera as al, AmbientLight as am, SpotLight as an, PointLight as ao, DirectionalLight as ap, BufferGeometry as aq, Group as ar, Quaternion as as, Bone as at, LineBasicMaterial as au, SkinnedMesh as av, Line as aw, LineSegments as ax, RepeatWrapping as ay, Skeleton as az, cloneTypedArray as b, CanvasTexture as b0, Shape as b1, SRGBToLinear as b2, ShapeGeometry as b3, DynamicDrawUsage as b4, ShaderChunk as b5, IMAGE_DEFAULT_COLOR_MODE_SETTINGS as b6, merge as b7, colorHasTransparency as b8, StaticDrawUsage as b9, RawShaderMaterial as ba, GLSL3 as bb, colorFieldComputedPrefix as bc, getRotationTo as bd, SphereGeometry as be, rgbaGradient as bf, InstancedBufferAttribute as bg, BoxGeometry as bh, DARK_OUTLINE as bi, LIGHT_OUTLINE as bj, CircleGeometry as bk, LineDashedMaterial as bl, GreaterDepth as bm, EventDispatcher as bn, Plane as bo, Raycaster as bp, WebGLRenderTarget as bq, THREE as br, Spherical as bs, WebGLRenderer as bt, NoToneMapping as bu, VSMShadowMap as bv, HemisphereLight as bw, copyObject as c, decodeRawImage as d, copyArray$1 as e, cloneBuffer as f, getPrototype as g, isPlainObject as h, initCloneObject as i, InstancedInterleavedBuffer as j, keysIn as k, InterleavedBufferAttribute as l, Vector2 as m, ShaderLib as n, UniformsUtils as o, ShaderMaterial as p, Vector4 as q, Mesh as r, MathUtils as s, rgbToThreeColor as t, stringToRgba as u, makeRgba as v, MeshStandardMaterial as w, rgbaToCssString as x, colorModeSettingsFields as y, autoSelectColorSettings as z };