@spiffcommerce/preview 3.6.2-rc.5 → 3.6.2-rc.6

package/dist/node_modules/@babylonjs/core/Misc/typeStore.esm.js

@@ -1,11 +0,0 @@
-const s = {};
-function n(e, t) {
-  s[e] = t;
-}
-function r(e) {
-  return s[e];
-}
-export {
-  r as GetClass,
-  n as RegisterClass
-};

package/dist/node_modules/@babylonjs/core/Misc/uniqueIdGenerator.esm.js

@@ -1,13 +0,0 @@
-class t {
-  /**
-   * Gets an unique (relatively to the current scene) Id
-   */
-  static get UniqueId() {
-    const e = this._UniqueIdCounter;
-    return this._UniqueIdCounter++, e;
-  }
-}
-t._UniqueIdCounter = 1;
-export {
-  t as UniqueIdGenerator
-};

package/dist/node_modules/@babylonjs/core/Misc/webRequest.esm.js

@@ -1,135 +0,0 @@
-function i() {
-  return typeof _native < "u" && _native.XMLHttpRequest ? new _native.XMLHttpRequest() : new XMLHttpRequest();
-}
-class s {
-  constructor() {
-    this._xhr = i(), this._requestURL = "";
-  }
-  _injectCustomRequestHeaders() {
-    if (!this._shouldSkipRequestModifications(this._requestURL))
-      for (const e in s.CustomRequestHeaders) {
-        const t = s.CustomRequestHeaders[e];
-        t && this._xhr.setRequestHeader(e, t);
-      }
-  }
-  _shouldSkipRequestModifications(e) {
-    return s.SkipRequestModificationForBabylonCDN && (e.includes("preview.babylonjs.com") || e.includes("cdn.babylonjs.com"));
-  }
-  /**
-   * Gets or sets a function to be called when loading progress changes
-   */
-  get onprogress() {
-    return this._xhr.onprogress;
-  }
-  set onprogress(e) {
-    this._xhr.onprogress = e;
-  }
-  /**
-   * Returns client's state
-   */
-  get readyState() {
-    return this._xhr.readyState;
-  }
-  /**
-   * Returns client's status
-   */
-  get status() {
-    return this._xhr.status;
-  }
-  /**
-   * Returns client's status as a text
-   */
-  get statusText() {
-    return this._xhr.statusText;
-  }
-  /**
-   * Returns client's response
-   */
-  get response() {
-    return this._xhr.response;
-  }
-  /**
-   * Returns client's response url
-   */
-  get responseURL() {
-    return this._xhr.responseURL;
-  }
-  /**
-   * Returns client's response as text
-   */
-  get responseText() {
-    return this._xhr.responseText;
-  }
-  /**
-   * Gets or sets the expected response type
-   */
-  get responseType() {
-    return this._xhr.responseType;
-  }
-  set responseType(e) {
-    this._xhr.responseType = e;
-  }
-  /**
-   * Gets or sets the timeout value in milliseconds
-   */
-  get timeout() {
-    return this._xhr.timeout;
-  }
-  set timeout(e) {
-    this._xhr.timeout = e;
-  }
-  addEventListener(e, t, r) {
-    this._xhr.addEventListener(e, t, r);
-  }
-  removeEventListener(e, t, r) {
-    this._xhr.removeEventListener(e, t, r);
-  }
-  /**
-   * Cancels any network activity
-   */
-  abort() {
-    this._xhr.abort();
-  }
-  /**
-   * Initiates the request. The optional argument provides the request body. The argument is ignored if request method is GET or HEAD
-   * @param body defines an optional request body
-   */
-  send(e) {
-    s.CustomRequestHeaders && this._injectCustomRequestHeaders(), this._xhr.send(e);
-  }
-  /**
-   * Sets the request method, request URL
-   * @param method defines the method to use (GET, POST, etc..)
-   * @param url defines the url to connect with
-   */
-  open(e, t) {
-    for (const r of s.CustomRequestModifiers) {
-      if (this._shouldSkipRequestModifications(t))
-        return;
-      r(this._xhr, t);
-    }
-    return t = t.replace("file:http:", "http:"), t = t.replace("file:https:", "https:"), this._requestURL = t, this._xhr.open(e, t, !0);
-  }
-  /**
-   * Sets the value of a request header.
-   * @param name The name of the header whose value is to be set
-   * @param value The value to set as the body of the header
-   */
-  setRequestHeader(e, t) {
-    this._xhr.setRequestHeader(e, t);
-  }
-  /**
-   * Get the string containing the text of a particular header's value.
-   * @param name The name of the header
-   * @returns The string containing the text of the given header name
-   */
-  getResponseHeader(e) {
-    return this._xhr.getResponseHeader(e);
-  }
-}
-s.CustomRequestHeaders = {};
-s.CustomRequestModifiers = new Array();
-s.SkipRequestModificationForBabylonCDN = !0;
-export {
-  s as WebRequest
-};

package/dist/node_modules/@babylonjs/core/Misc/workerPool.esm.js

@@ -1,80 +0,0 @@
-class h {
-  /**
-   * Constructor
-   * @param workers Array of workers to use for actions
-   */
-  constructor(e) {
-    this._pendingActions = new Array(), this._workerInfos = e.map((s) => ({
-      workerPromise: Promise.resolve(s),
-      idle: !0
-    }));
-  }
-  /**
-   * Terminates all workers and clears any pending actions.
-   */
-  dispose() {
-    for (const e of this._workerInfos)
-      e.workerPromise.then((s) => {
-        s.terminate();
-      });
-    this._workerInfos.length = 0, this._pendingActions.length = 0;
-  }
-  /**
-   * Pushes an action to the worker pool. If all the workers are active, the action will be
-   * pended until a worker has completed its action.
-   * @param action The action to perform. Call onComplete when the action is complete.
-   */
-  push(e) {
-    this._executeOnIdleWorker(e) || this._pendingActions.push(e);
-  }
-  _executeOnIdleWorker(e) {
-    for (const s of this._workerInfos)
-      if (s.idle)
-        return this._execute(s, e), !0;
-    return !1;
-  }
-  _execute(e, s) {
-    e.idle = !1, e.workerPromise.then((t) => {
-      s(t, () => {
-        const i = this._pendingActions.shift();
-        i ? this._execute(e, i) : e.idle = !0;
-      });
-    });
-  }
-}
-class r extends h {
-  constructor(e, s, t = r.DefaultOptions) {
-    super([]), this._maxWorkers = e, this._createWorkerAsync = s, this._options = t;
-  }
-  push(e) {
-    if (!this._executeOnIdleWorker(e))
-      if (this._workerInfos.length < this._maxWorkers) {
-        const s = {
-          workerPromise: this._createWorkerAsync(),
-          idle: !1
-        };
-        this._workerInfos.push(s), this._execute(s, e);
-      } else
-        this._pendingActions.push(e);
-  }
-  _execute(e, s) {
-    e.timeoutId && (clearTimeout(e.timeoutId), delete e.timeoutId), super._execute(e, (t, i) => {
-      s(t, () => {
-        i(), e.idle && (e.timeoutId = setTimeout(() => {
-          e.workerPromise.then((n) => {
-            n.terminate();
-          });
-          const o = this._workerInfos.indexOf(e);
-          o !== -1 && this._workerInfos.splice(o, 1);
-        }, this._options.idleTimeElapsedBeforeRelease));
-      });
-    });
-  }
-}
-r.DefaultOptions = {
-  idleTimeElapsedBeforeRelease: 1e3
-};
-export {
-  r as AutoReleaseWorkerPool,
-  h as WorkerPool
-};

package/dist/node_modules/@babylonjs/core/Morph/morphTarget.esm.js

@@ -1,187 +0,0 @@
-import { __decorate as l } from "../tslib.es6.esm.js";
-import { Observable as o } from "../Misc/observable.esm.js";
-import { EngineStore as d } from "../Engines/engineStore.esm.js";
-import { VertexBuffer as i } from "../Buffers/buffer.esm.js";
-import { serialize as m, SerializationHelper as h } from "../Misc/decorators.esm.js";
-import { GetClass as f } from "../Misc/typeStore.esm.js";
-class r {
-  /**
-   * Gets or sets the influence of this target (ie. its weight in the overall morphing)
-   */
-  get influence() {
-    return this._influence;
-  }
-  set influence(t) {
-    if (this._influence === t)
-      return;
-    const s = this._influence;
-    this._influence = t, this.onInfluenceChanged.hasObservers() && this.onInfluenceChanged.notifyObservers(s === 0 || t === 0);
-  }
-  /**
-   * Gets or sets the animation properties override
-   */
-  get animationPropertiesOverride() {
-    return !this._animationPropertiesOverride && this._scene ? this._scene.animationPropertiesOverride : this._animationPropertiesOverride;
-  }
-  set animationPropertiesOverride(t) {
-    this._animationPropertiesOverride = t;
-  }
-  /**
-   * Creates a new MorphTarget
-   * @param name defines the name of the target
-   * @param influence defines the influence to use
-   * @param scene defines the scene the morphtarget belongs to
-   */
-  constructor(t, s = 0, n = null) {
-    this.name = t, this.animations = new Array(), this._positions = null, this._normals = null, this._tangents = null, this._uvs = null, this._uniqueId = 0, this.onInfluenceChanged = new o(), this._onDataLayoutChanged = new o(), this._animationPropertiesOverride = null, this._scene = n || d.LastCreatedScene, this.influence = s, this._scene && (this._uniqueId = this._scene.getUniqueId());
-  }
-  /**
-   * Gets the unique ID of this manager
-   */
-  get uniqueId() {
-    return this._uniqueId;
-  }
-  /**
-   * Gets a boolean defining if the target contains position data
-   */
-  get hasPositions() {
-    return !!this._positions;
-  }
-  /**
-   * Gets a boolean defining if the target contains normal data
-   */
-  get hasNormals() {
-    return !!this._normals;
-  }
-  /**
-   * Gets a boolean defining if the target contains tangent data
-   */
-  get hasTangents() {
-    return !!this._tangents;
-  }
-  /**
-   * Gets a boolean defining if the target contains texture coordinates data
-   */
-  get hasUVs() {
-    return !!this._uvs;
-  }
-  /**
-   * Affects position data to this target
-   * @param data defines the position data to use
-   */
-  setPositions(t) {
-    const s = this.hasPositions;
-    this._positions = t, s !== this.hasPositions && this._onDataLayoutChanged.notifyObservers(void 0);
-  }
-  /**
-   * Gets the position data stored in this target
-   * @returns a FloatArray containing the position data (or null if not present)
-   */
-  getPositions() {
-    return this._positions;
-  }
-  /**
-   * Affects normal data to this target
-   * @param data defines the normal data to use
-   */
-  setNormals(t) {
-    const s = this.hasNormals;
-    this._normals = t, s !== this.hasNormals && this._onDataLayoutChanged.notifyObservers(void 0);
-  }
-  /**
-   * Gets the normal data stored in this target
-   * @returns a FloatArray containing the normal data (or null if not present)
-   */
-  getNormals() {
-    return this._normals;
-  }
-  /**
-   * Affects tangent data to this target
-   * @param data defines the tangent data to use
-   */
-  setTangents(t) {
-    const s = this.hasTangents;
-    this._tangents = t, s !== this.hasTangents && this._onDataLayoutChanged.notifyObservers(void 0);
-  }
-  /**
-   * Gets the tangent data stored in this target
-   * @returns a FloatArray containing the tangent data (or null if not present)
-   */
-  getTangents() {
-    return this._tangents;
-  }
-  /**
-   * Affects texture coordinates data to this target
-   * @param data defines the texture coordinates data to use
-   */
-  setUVs(t) {
-    const s = this.hasUVs;
-    this._uvs = t, s !== this.hasUVs && this._onDataLayoutChanged.notifyObservers(void 0);
-  }
-  /**
-   * Gets the texture coordinates data stored in this target
-   * @returns a FloatArray containing the texture coordinates data (or null if not present)
-   */
-  getUVs() {
-    return this._uvs;
-  }
-  /**
-   * Clone the current target
-   * @returns a new MorphTarget
-   */
-  clone() {
-    const t = h.Clone(() => new r(this.name, this.influence, this._scene), this);
-    return t._positions = this._positions, t._normals = this._normals, t._tangents = this._tangents, t._uvs = this._uvs, t;
-  }
-  /**
-   * Serializes the current target into a Serialization object
-   * @returns the serialized object
-   */
-  serialize() {
-    const t = {};
-    return t.name = this.name, t.influence = this.influence, t.positions = Array.prototype.slice.call(this.getPositions()), this.id != null && (t.id = this.id), this.hasNormals && (t.normals = Array.prototype.slice.call(this.getNormals())), this.hasTangents && (t.tangents = Array.prototype.slice.call(this.getTangents())), this.hasUVs && (t.uvs = Array.prototype.slice.call(this.getUVs())), h.AppendSerializedAnimations(this, t), t;
-  }
-  /**
-   * Returns the string "MorphTarget"
-   * @returns "MorphTarget"
-   */
-  getClassName() {
-    return "MorphTarget";
-  }
-  // Statics
-  /**
-   * Creates a new target from serialized data
-   * @param serializationObject defines the serialized data to use
-   * @param scene defines the hosting scene
-   * @returns a new MorphTarget
-   */
-  static Parse(t, s) {
-    const n = new r(t.name, t.influence);
-    if (n.setPositions(t.positions), t.id != null && (n.id = t.id), t.normals && n.setNormals(t.normals), t.tangents && n.setTangents(t.tangents), t.uvs && n.setUVs(t.uvs), t.animations) {
-      for (let e = 0; e < t.animations.length; e++) {
-        const u = t.animations[e], a = f("BABYLON.Animation");
-        a && n.animations.push(a.Parse(u));
-      }
-      t.autoAnimate && s && s.beginAnimation(n, t.autoAnimateFrom, t.autoAnimateTo, t.autoAnimateLoop, t.autoAnimateSpeed || 1);
-    }
-    return n;
-  }
-  /**
-   * Creates a MorphTarget from mesh data
-   * @param mesh defines the source mesh
-   * @param name defines the name to use for the new target
-   * @param influence defines the influence to attach to the target
-   * @returns a new MorphTarget
-   */
-  static FromMesh(t, s, n) {
-    s || (s = t.name);
-    const e = new r(s, n, t.getScene());
-    return e.setPositions(t.getVerticesData(i.PositionKind)), t.isVerticesDataPresent(i.NormalKind) && e.setNormals(t.getVerticesData(i.NormalKind)), t.isVerticesDataPresent(i.TangentKind) && e.setTangents(t.getVerticesData(i.TangentKind)), t.isVerticesDataPresent(i.UVKind) && e.setUVs(t.getVerticesData(i.UVKind)), e;
-  }
-}
-l([
-  m()
-], r.prototype, "id", void 0);
-export {
-  r as MorphTarget
-};

package/dist/node_modules/@babylonjs/core/Morph/morphTargetManager.esm.js

@@ -1,249 +0,0 @@
-import { SmartArray as l } from "../Misc/smartArray.esm.js";
-import { Logger as c } from "../Misc/logger.esm.js";
-import { EngineStore as T } from "../Engines/engineStore.esm.js";
-import { MorphTarget as x } from "./morphTarget.esm.js";
-import { RawTexture2DArray as f } from "../Materials/Textures/rawTexture2DArray.esm.js";
-class h {
-  /**
-   * Sets a boolean indicating that adding new target or updating an existing target will not update the underlying data buffers
-   */
-  set areUpdatesFrozen(t) {
-    t ? this._blockCounter++ : (this._blockCounter--, this._blockCounter <= 0 && (this._blockCounter = 0, this._syncActiveTargets(!0)));
-  }
-  get areUpdatesFrozen() {
-    return this._blockCounter > 0;
-  }
-  /**
-   * Creates a new MorphTargetManager
-   * @param scene defines the current scene
-   */
-  constructor(t = null) {
-    if (this._targets = new Array(), this._targetInfluenceChangedObservers = new Array(), this._targetDataLayoutChangedObservers = new Array(), this._activeTargets = new l(16), this._supportsNormals = !1, this._supportsTangents = !1, this._supportsUVs = !1, this._vertexCount = 0, this._textureVertexStride = 0, this._textureWidth = 0, this._textureHeight = 1, this._uniqueId = 0, this._tempInfluences = new Array(), this._canUseTextureForTargets = !1, this._blockCounter = 0, this._parentContainer = null, this.optimizeInfluencers = !0, this.enableNormalMorphing = !0, this.enableTangentMorphing = !0, this.enableUVMorphing = !0, this._useTextureToStoreTargets = !0, t || (t = T.LastCreatedScene), this._scene = t, this._scene) {
-      this._scene.addMorphTargetManager(this), this._uniqueId = this._scene.getUniqueId();
-      const e = this._scene.getEngine().getCaps();
-      this._canUseTextureForTargets = e.canUseGLVertexID && e.textureFloat && e.maxVertexTextureImageUnits > 0 && e.texture2DArrayMaxLayerCount > 1;
-    }
-  }
-  /**
-   * Gets the unique ID of this manager
-   */
-  get uniqueId() {
-    return this._uniqueId;
-  }
-  /**
-   * Gets the number of vertices handled by this manager
-   */
-  get vertexCount() {
-    return this._vertexCount;
-  }
-  /**
-   * Gets a boolean indicating if this manager supports morphing of normals
-   */
-  get supportsNormals() {
-    return this._supportsNormals && this.enableNormalMorphing;
-  }
-  /**
-   * Gets a boolean indicating if this manager supports morphing of tangents
-   */
-  get supportsTangents() {
-    return this._supportsTangents && this.enableTangentMorphing;
-  }
-  /**
-   * Gets a boolean indicating if this manager supports morphing of texture coordinates
-   */
-  get supportsUVs() {
-    return this._supportsUVs && this.enableUVMorphing;
-  }
-  /**
-   * Gets the number of targets stored in this manager
-   */
-  get numTargets() {
-    return this._targets.length;
-  }
-  /**
-   * Gets the number of influencers (ie. the number of targets with influences > 0)
-   */
-  get numInfluencers() {
-    return this._activeTargets.length;
-  }
-  /**
-   * Gets the list of influences (one per target)
-   */
-  get influences() {
-    return this._influences;
-  }
-  /**
-   * Gets or sets a boolean indicating that targets should be stored as a texture instead of using vertex attributes (default is true).
-   * Please note that this option is not available if the hardware does not support it
-   */
-  get useTextureToStoreTargets() {
-    return this._useTextureToStoreTargets;
-  }
-  set useTextureToStoreTargets(t) {
-    this._useTextureToStoreTargets = t;
-  }
-  /**
-   * Gets a boolean indicating that the targets are stored into a texture (instead of as attributes)
-   */
-  get isUsingTextureForTargets() {
-    var t;
-    return h.EnableTextureStorage && this.useTextureToStoreTargets && this._canUseTextureForTargets && !(!((t = this._scene) === null || t === void 0) && t.getEngine().getCaps().disableMorphTargetTexture);
-  }
-  /**
-   * Gets the active target at specified index. An active target is a target with an influence > 0
-   * @param index defines the index to check
-   * @returns the requested target
-   */
-  getActiveTarget(t) {
-    return this._activeTargets.data[t];
-  }
-  /**
-   * Gets the target at specified index
-   * @param index defines the index to check
-   * @returns the requested target
-   */
-  getTarget(t) {
-    return this._targets[t];
-  }
-  /**
-   * Add a new target to this manager
-   * @param target defines the target to add
-   */
-  addTarget(t) {
-    this._targets.push(t), this._targetInfluenceChangedObservers.push(t.onInfluenceChanged.add((e) => {
-      this._syncActiveTargets(e);
-    })), this._targetDataLayoutChangedObservers.push(t._onDataLayoutChanged.add(() => {
-      this._syncActiveTargets(!0);
-    })), this._syncActiveTargets(!0);
-  }
-  /**
-   * Removes a target from the manager
-   * @param target defines the target to remove
-   */
-  removeTarget(t) {
-    const e = this._targets.indexOf(t);
-    e >= 0 && (this._targets.splice(e, 1), t.onInfluenceChanged.remove(this._targetInfluenceChangedObservers.splice(e, 1)[0]), t._onDataLayoutChanged.remove(this._targetDataLayoutChangedObservers.splice(e, 1)[0]), this._syncActiveTargets(!0)), this._scene && this._scene.stopAnimation(t);
-  }
-  /**
-   * @internal
-   */
-  _bind(t) {
-    t.setFloat3("morphTargetTextureInfo", this._textureVertexStride, this._textureWidth, this._textureHeight), t.setFloatArray("morphTargetTextureIndices", this._morphTargetTextureIndices), t.setTexture("morphTargets", this._targetStoreTexture);
-  }
-  /**
-   * Clone the current manager
-   * @returns a new MorphTargetManager
-   */
-  clone() {
-    const t = new h(this._scene);
-    for (const e of this._targets)
-      t.addTarget(e.clone());
-    return t.enableNormalMorphing = this.enableNormalMorphing, t.enableTangentMorphing = this.enableTangentMorphing, t.enableUVMorphing = this.enableUVMorphing, t;
-  }
-  /**
-   * Serializes the current manager into a Serialization object
-   * @returns the serialized object
-   */
-  serialize() {
-    const t = {};
-    t.id = this.uniqueId, t.targets = [];
-    for (const e of this._targets)
-      t.targets.push(e.serialize());
-    return t;
-  }
-  _syncActiveTargets(t) {
-    if (this.areUpdatesFrozen)
-      return;
-    let e = 0;
-    this._activeTargets.reset(), this._supportsNormals = !0, this._supportsTangents = !0, this._supportsUVs = !0, this._vertexCount = 0, this._scene && this._targets.length > this._scene.getEngine().getCaps().texture2DArrayMaxLayerCount && (this.useTextureToStoreTargets = !1), (!this._morphTargetTextureIndices || this._morphTargetTextureIndices.length !== this._targets.length) && (this._morphTargetTextureIndices = new Float32Array(this._targets.length));
-    let i = -1;
-    for (const s of this._targets) {
-      if (i++, s.influence === 0 && this.optimizeInfluencers)
-        continue;
-      if (this._activeTargets.length >= h.MaxActiveMorphTargetsInVertexAttributeMode && !this.isUsingTextureForTargets)
-        break;
-      this._activeTargets.push(s), this._morphTargetTextureIndices[e] = i, this._tempInfluences[e++] = s.influence, this._supportsNormals = this._supportsNormals && s.hasNormals, this._supportsTangents = this._supportsTangents && s.hasTangents, this._supportsUVs = this._supportsUVs && s.hasUVs;
-      const r = s.getPositions();
-      if (r) {
-        const a = r.length / 3;
-        if (this._vertexCount === 0)
-          this._vertexCount = a;
-        else if (this._vertexCount !== a) {
-          c.Error("Incompatible target. Targets must all have the same vertices count.");
-          return;
-        }
-      }
-    }
-    this._morphTargetTextureIndices.length !== e && (this._morphTargetTextureIndices = this._morphTargetTextureIndices.slice(0, e)), (!this._influences || this._influences.length !== e) && (this._influences = new Float32Array(e));
-    for (let s = 0; s < e; s++)
-      this._influences[s] = this._tempInfluences[s];
-    t && this.synchronize();
-  }
-  /**
-   * Synchronize the targets with all the meshes using this morph target manager
-   */
-  synchronize() {
-    if (!(!this._scene || this.areUpdatesFrozen)) {
-      if (this.isUsingTextureForTargets && this._vertexCount) {
-        this._textureVertexStride = 1, this._supportsNormals && this._textureVertexStride++, this._supportsTangents && this._textureVertexStride++, this._supportsUVs && this._textureVertexStride++, this._textureWidth = this._vertexCount * this._textureVertexStride, this._textureHeight = 1;
-        const t = this._scene.getEngine().getCaps().maxTextureSize;
-        this._textureWidth > t && (this._textureHeight = Math.ceil(this._textureWidth / t), this._textureWidth = t);
-        let e = !0;
-        if (this._targetStoreTexture) {
-          const i = this._targetStoreTexture.getSize();
-          i.width === this._textureWidth && i.height === this._textureHeight && this._targetStoreTexture.depth === this._targets.length && (e = !1);
-        }
-        if (e) {
-          this._targetStoreTexture && this._targetStoreTexture.dispose();
-          const i = this._targets.length, s = new Float32Array(i * this._textureWidth * this._textureHeight * 4);
-          let r = 0;
-          for (let a = 0; a < i; a++) {
-            const o = this._targets[a], u = o.getPositions(), g = o.getNormals(), p = o.getUVs(), _ = o.getTangents();
-            if (!u) {
-              a === 0 && c.Error("Invalid morph target. Target must have positions.");
-              return;
-            }
-            r = a * this._textureWidth * this._textureHeight * 4;
-            for (let n = 0; n < this._vertexCount; n++)
-              s[r] = u[n * 3], s[r + 1] = u[n * 3 + 1], s[r + 2] = u[n * 3 + 2], r += 4, this._supportsNormals && g && (s[r] = g[n * 3], s[r + 1] = g[n * 3 + 1], s[r + 2] = g[n * 3 + 2], r += 4), this._supportsUVs && p && (s[r] = p[n * 2], s[r + 1] = p[n * 2 + 1], r += 4), this._supportsTangents && _ && (s[r] = _[n * 3], s[r + 1] = _[n * 3 + 1], s[r + 2] = _[n * 3 + 2], r += 4);
-          }
-          this._targetStoreTexture = f.CreateRGBATexture(s, this._textureWidth, this._textureHeight, i, this._scene, !1, !1, 1, 1);
-        }
-      }
-      for (const t of this._scene.meshes)
-        t.morphTargetManager === this && t._syncGeometryWithMorphTargetManager();
-    }
-  }
-  /**
-   * Release all resources
-   */
-  dispose() {
-    if (this._targetStoreTexture && this._targetStoreTexture.dispose(), this._targetStoreTexture = null, this._scene) {
-      if (this._scene.removeMorphTargetManager(this), this._parentContainer) {
-        const t = this._parentContainer.morphTargetManagers.indexOf(this);
-        t > -1 && this._parentContainer.morphTargetManagers.splice(t, 1), this._parentContainer = null;
-      }
-      for (const t of this._targets)
-        this._scene.stopAnimation(t);
-    }
-  }
-  // Statics
-  /**
-   * Creates a new MorphTargetManager from serialized data
-   * @param serializationObject defines the serialized data
-   * @param scene defines the hosting scene
-   * @returns the new MorphTargetManager
-   */
-  static Parse(t, e) {
-    const i = new h(e);
-    i._uniqueId = t.id;
-    for (const s of t.targets)
-      i.addTarget(x.Parse(s, e));
-    return i;
-  }
-}
-h.EnableTextureStorage = !0;
-h.MaxActiveMorphTargetsInVertexAttributeMode = 8;
-export {
-  h as MorphTargetManager
-};