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

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

@@ -0,0 +1,144 @@
+import { PrecisionDate as a } from "./precisionDate.esm.js";
+class l {
+  /**
+   * constructor
+   * @param frameSampleSize The number of samples required to saturate the sliding window
+   */
+  constructor(e = 30) {
+    this._enabled = !0, this._rollingFrameTime = new r(e);
+  }
+  /**
+   * Samples current frame
+   * @param timeMs A timestamp in milliseconds of the current frame to compare with other frames
+   */
+  sampleFrame(e = a.Now) {
+    if (this._enabled) {
+      if (this._lastFrameTimeMs != null) {
+        const t = e - this._lastFrameTimeMs;
+        this._rollingFrameTime.add(t);
+      }
+      this._lastFrameTimeMs = e;
+    }
+  }
+  /**
+   * Returns the average frame time in milliseconds over the sliding window (or the subset of frames sampled so far)
+   */
+  get averageFrameTime() {
+    return this._rollingFrameTime.average;
+  }
+  /**
+   * Returns the variance frame time in milliseconds over the sliding window (or the subset of frames sampled so far)
+   */
+  get averageFrameTimeVariance() {
+    return this._rollingFrameTime.variance;
+  }
+  /**
+   * Returns the frame time of the most recent frame
+   */
+  get instantaneousFrameTime() {
+    return this._rollingFrameTime.history(0);
+  }
+  /**
+   * Returns the average framerate in frames per second over the sliding window (or the subset of frames sampled so far)
+   */
+  get averageFPS() {
+    return 1e3 / this._rollingFrameTime.average;
+  }
+  /**
+   * Returns the average framerate in frames per second using the most recent frame time
+   */
+  get instantaneousFPS() {
+    const e = this._rollingFrameTime.history(0);
+    return e === 0 ? 0 : 1e3 / e;
+  }
+  /**
+   * Returns true if enough samples have been taken to completely fill the sliding window
+   */
+  get isSaturated() {
+    return this._rollingFrameTime.isSaturated();
+  }
+  /**
+   * Enables contributions to the sliding window sample set
+   */
+  enable() {
+    this._enabled = !0;
+  }
+  /**
+   * Disables contributions to the sliding window sample set
+   * Samples will not be interpolated over the disabled period
+   */
+  disable() {
+    this._enabled = !1, this._lastFrameTimeMs = null;
+  }
+  /**
+   * Returns true if sampling is enabled
+   */
+  get isEnabled() {
+    return this._enabled;
+  }
+  /**
+   * Resets performance monitor
+   */
+  reset() {
+    this._lastFrameTimeMs = null, this._rollingFrameTime.reset();
+  }
+}
+class r {
+  /**
+   * constructor
+   * @param length The number of samples required to saturate the sliding window
+   */
+  constructor(e) {
+    this._samples = new Array(e), this.reset();
+  }
+  /**
+   * Adds a sample to the sample set
+   * @param v The sample value
+   */
+  add(e) {
+    let t;
+    if (this.isSaturated()) {
+      const s = this._samples[this._pos];
+      t = s - this.average, this.average -= t / (this._sampleCount - 1), this._m2 -= t * (s - this.average);
+    } else
+      this._sampleCount++;
+    t = e - this.average, this.average += t / this._sampleCount, this._m2 += t * (e - this.average), this.variance = this._m2 / (this._sampleCount - 1), this._samples[this._pos] = e, this._pos++, this._pos %= this._samples.length;
+  }
+  /**
+   * Returns previously added values or null if outside of history or outside the sliding window domain
+   * @param i Index in history. For example, pass 0 for the most recent value and 1 for the value before that
+   * @returns Value previously recorded with add() or null if outside of range
+   */
+  history(e) {
+    if (e >= this._sampleCount || e >= this._samples.length)
+      return 0;
+    const t = this._wrapPosition(this._pos - 1);
+    return this._samples[this._wrapPosition(t - e)];
+  }
+  /**
+   * Returns true if enough samples have been taken to completely fill the sliding window
+   * @returns true if sample-set saturated
+   */
+  isSaturated() {
+    return this._sampleCount >= this._samples.length;
+  }
+  /**
+   * Resets the rolling average (equivalent to 0 samples taken so far)
+   */
+  reset() {
+    this.average = 0, this.variance = 0, this._sampleCount = 0, this._pos = 0, this._m2 = 0;
+  }
+  /**
+   * Wraps a value around the sample range boundaries
+   * @param i Position in sample range, for example if the sample length is 5, and i is -3, then 2 will be returned.
+   * @returns Wrapped position in sample range
+   */
+  _wrapPosition(e) {
+    const t = this._samples.length;
+    return (e % t + t) % t;
+  }
+}
+export {
+  l as PerformanceMonitor,
+  r as RollingAverage
+};

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

@@ -0,0 +1,12 @@
+import { IsWindowObjectExist as o } from "./domManagement.esm.js";
+class n {
+  /**
+   * Gets either window.performance.now() if supported or Date.now() else
+   */
+  static get Now() {
+    return o() && window.performance && window.performance.now ? window.performance.now() : Date.now();
+  }
+}
+export {
+  n as PrecisionDate
+};

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

@@ -0,0 +1,14 @@
+class n {
+  /**
+   * Function used to defines an exponential back off strategy
+   * @param maxRetries defines the maximum number of retries (3 by default)
+   * @param baseInterval defines the interval between retries
+   * @returns the strategy function to use
+   */
+  static ExponentialBackoff(a = 3, e = 500) {
+    return (r, f, t) => f.status !== 0 || t >= a || r.indexOf("file:") !== -1 ? -1 : Math.pow(2, t) * e;
+  }
+}
+export {
+  n as RetryStrategy
+};

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

@@ -0,0 +1,51 @@
+import { PostProcess as u } from "../PostProcesses/postProcess.esm.js";
+import "../Shaders/rgbdDecode.fragment.esm.js";
+import "../Engines/Extensions/engine.renderTarget.esm.js";
+import { ApplyPostProcess as p } from "./textureTools.esm.js";
+class T {
+  /**
+   * Expand the RGBD Texture from RGBD to Half Float if possible.
+   * @param texture the texture to expand.
+   */
+  static ExpandRGBDTexture(r) {
+    const e = r._texture;
+    if (!e || !r.isRGBD)
+      return;
+    const t = e.getEngine(), a = t.getCaps(), d = e.isReady;
+    let s = !1;
+    a.textureHalfFloatRender && a.textureHalfFloatLinearFiltering ? (s = !0, e.type = 2) : a.textureFloatRender && a.textureFloatLinearFiltering && (s = !0, e.type = 1), s && (e.isReady = !1, e._isRGBD = !1, e.invertY = !1);
+    const l = () => {
+      if (s) {
+        const n = new u("rgbdDecode", "rgbdDecode", null, null, 1, null, 3, t, !1, void 0, e.type, void 0, null, !1);
+        n.externalTextureSamplerBinding = !0;
+        const i = t.createRenderTargetTexture(e.width, {
+          generateDepthBuffer: !1,
+          generateMipMaps: !1,
+          generateStencilBuffer: !1,
+          samplingMode: e.samplingMode,
+          type: e.type,
+          format: 5
+        });
+        n.getEffect().executeWhenCompiled(() => {
+          n.onApply = (o) => {
+            o._bindTexture("textureSampler", e), o.setFloat2("scale", 1, 1);
+          }, r.getScene().postProcessManager.directRender([n], i, !0), t.restoreDefaultFramebuffer(), t._releaseTexture(e), n && n.dispose(), i._swapAndDie(e), e.isReady = !0;
+        });
+      }
+    };
+    d ? l() : r.onLoadObservable.addOnce(l);
+  }
+  /**
+   * Encode the texture to RGBD if possible.
+   * @param internalTexture the texture to encode
+   * @param scene the scene hosting the texture
+   * @param outputTextureType type of the texture in which the encoding is performed
+   * @returns a promise with the internalTexture having its texture replaced by the result of the processing
+   */
+  static EncodeTextureToRGBD(r, e, t = 0) {
+    return p("rgbdEncode", r, e, t, 1, 5);
+  }
+}
+export {
+  T as RGBDTextureTools
+};

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

@@ -0,0 +1,92 @@
+import { Texture as D } from "../Materials/Textures/texture.esm.js";
+import { RenderTargetTexture as I } from "../Materials/Textures/renderTargetTexture.esm.js";
+import { FxaaPostProcess as O } from "../PostProcesses/fxaaPostProcess.esm.js";
+import { Logger as A } from "./logger.esm.js";
+import { Tools as w } from "./tools.esm.js";
+import { DumpTools as v } from "./dumpTools.esm.js";
+import { ApplyPostProcess as L } from "./textureTools.esm.js";
+let p = null;
+function W(t, o, e, n, r = "image/png", i = !1, d) {
+  const { height: f, width: u } = H(t, o, e);
+  if (!(f && u)) {
+    A.Error("Invalid 'size' parameter !");
+    return;
+  }
+  p || (p = document.createElement("canvas")), p.width = u, p.height = f;
+  const S = p.getContext("2d"), R = t.getRenderWidth() / t.getRenderHeight();
+  let l = u, a = l / R;
+  a > f && (a = f, l = a * R);
+  const h = Math.max(0, u - l) / 2, M = Math.max(0, f - a) / 2;
+  o.getScene().activeCamera !== o ? P(t, o, e, (m) => {
+    if (i) {
+      const C = new Blob([m]);
+      w.DownloadBlob(C), n && n("");
+    } else
+      n && n(m);
+  }, r, 1, t.getCreationOptions().antialias, void 0, void 0, void 0, void 0, d) : t.onEndFrameObservable.addOnce(() => {
+    const m = t.getRenderingCanvas();
+    S && m && S.drawImage(m, h, M, l, a), p && (i ? (w.EncodeScreenshotCanvasData(p, void 0, r, void 0, d), n && n("")) : w.EncodeScreenshotCanvasData(p, n, r, void 0, d));
+  });
+}
+function y(t, o, e, n = "image/png", r) {
+  return new Promise((i, d) => {
+    W(t, o, e, (f) => {
+      typeof f < "u" ? i(f) : d(new Error("Data is undefined"));
+    }, n, void 0, r);
+  });
+}
+function P(t, o, e, n, r = "image/png", i = 1, d = !1, f, u = !1, S = !1, R = !0, l) {
+  const { height: a, width: h, finalWidth: M, finalHeight: x } = H(t, o, e), m = { width: h, height: a };
+  if (!(a && h)) {
+    A.Error("Invalid 'size' parameter !");
+    return;
+  }
+  const C = { width: t.getRenderWidth(), height: t.getRenderHeight() };
+  t.setSize(h, a);
+  const g = o.getScene(), s = new I("screenShot", m, g, !1, !1, 0, !1, D.BILINEAR_SAMPLINGMODE, void 0, S, void 0, void 0, void 0, i);
+  s.renderList = g.meshes.slice(), s.samples = i, s.renderSprites = u, s.activeCamera = o, s.forceLayerMaskCheck = R;
+  const E = () => {
+    t.onEndFrameObservable.addOnce(() => {
+      M === h && x === a ? s.readPixels(void 0, void 0, void 0, !1).then((c) => {
+        v.DumpData(h, a, c, n, r, f, !0, void 0, l), s.dispose();
+      }) : L("pass", s.getInternalTexture(), g, void 0, void 0, void 0, M, x).then((c) => {
+        t._readTexturePixels(c, M, x, -1, 0, null, !0, !1, 0, 0).then((T) => {
+          v.DumpData(M, x, T, n, r, f, !0, void 0, l), c.dispose();
+        });
+      });
+    }), g.incrementRenderId(), g.resetCachedMaterial(), s.render(!0), g.incrementRenderId(), g.resetCachedMaterial(), t.setSize(C.width, C.height), o.getProjectionMatrix(!0), g.render();
+  };
+  if (d) {
+    const c = new O("antialiasing", 1, g.activeCamera);
+    s.addPostProcess(c), c.getEffect().isReady() ? E() : c.getEffect().onCompiled = () => {
+      E();
+    };
+  } else
+    E();
+}
+function U(t, o, e, n = "image/png", r = 1, i = !1, d, f = !1, u = !1, S = !0, R) {
+  return new Promise((l, a) => {
+    P(t, o, e, (h) => {
+      typeof h < "u" ? l(h) : a(new Error("Data is undefined"));
+    }, n, r, i, d, f, u, S, R);
+  });
+}
+function H(t, o, e) {
+  let n = 0, r = 0, i = 0, d = 0;
+  if (typeof e == "object") {
+    const f = e.precision ? Math.abs(e.precision) : 1;
+    e.width && e.height ? (n = e.height * f, r = e.width * f) : e.width && !e.height ? (r = e.width * f, n = Math.round(r / t.getAspectRatio(o))) : e.height && !e.width ? (n = e.height * f, r = Math.round(n * t.getAspectRatio(o))) : (r = Math.round(t.getRenderWidth() * f), n = Math.round(r / t.getAspectRatio(o))), e.finalWidth && e.finalHeight ? (d = e.finalHeight, i = e.finalWidth) : e.finalWidth && !e.finalHeight ? (i = e.finalWidth, d = Math.round(i / t.getAspectRatio(o))) : e.finalHeight && !e.finalWidth ? (d = e.finalHeight, i = Math.round(d * t.getAspectRatio(o))) : (i = r, d = n);
+  } else
+    isNaN(e) || (n = e, r = e, i = e, d = e);
+  return r && (r = Math.floor(r)), n && (n = Math.floor(n)), i && (i = Math.floor(i)), d && (d = Math.floor(d)), { height: n | 0, width: r | 0, finalWidth: i | 0, finalHeight: d | 0 };
+}
+const b = () => {
+  w.CreateScreenshot = W, w.CreateScreenshotAsync = y, w.CreateScreenshotUsingRenderTarget = P, w.CreateScreenshotUsingRenderTargetAsync = U;
+};
+b();
+export {
+  W as CreateScreenshot,
+  y as CreateScreenshotAsync,
+  P as CreateScreenshotUsingRenderTarget,
+  U as CreateScreenshotUsingRenderTargetAsync
+};

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

@@ -0,0 +1,118 @@
+class h {
+  /**
+   * Instantiates a Smart Array.
+   * @param capacity defines the default capacity of the array.
+   */
+  constructor(t) {
+    this.length = 0, this.data = new Array(t), this._id = h._GlobalId++;
+  }
+  /**
+   * Pushes a value at the end of the active data.
+   * @param value defines the object to push in the array.
+   */
+  push(t) {
+    this.data[this.length++] = t, this.length > this.data.length && (this.data.length *= 2);
+  }
+  /**
+   * Iterates over the active data and apply the lambda to them.
+   * @param func defines the action to apply on each value.
+   */
+  forEach(t) {
+    for (let s = 0; s < this.length; s++)
+      t(this.data[s]);
+  }
+  /**
+   * Sorts the full sets of data.
+   * @param compareFn defines the comparison function to apply.
+   */
+  sort(t) {
+    this.data.sort(t);
+  }
+  /**
+   * Resets the active data to an empty array.
+   */
+  reset() {
+    this.length = 0;
+  }
+  /**
+   * Releases all the data from the array as well as the array.
+   */
+  dispose() {
+    this.reset(), this.data && (this.data.length = 0);
+  }
+  /**
+   * Concats the active data with a given array.
+   * @param array defines the data to concatenate with.
+   */
+  concat(t) {
+    if (t.length !== 0) {
+      this.length + t.length > this.data.length && (this.data.length = (this.length + t.length) * 2);
+      for (let s = 0; s < t.length; s++)
+        this.data[this.length++] = (t.data || t)[s];
+    }
+  }
+  /**
+   * Returns the position of a value in the active data.
+   * @param value defines the value to find the index for
+   * @returns the index if found in the active data otherwise -1
+   */
+  indexOf(t) {
+    const s = this.data.indexOf(t);
+    return s >= this.length ? -1 : s;
+  }
+  /**
+   * Returns whether an element is part of the active data.
+   * @param value defines the value to look for
+   * @returns true if found in the active data otherwise false
+   */
+  contains(t) {
+    return this.indexOf(t) !== -1;
+  }
+}
+h._GlobalId = 0;
+class n extends h {
+  constructor() {
+    super(...arguments), this._duplicateId = 0;
+  }
+  /**
+   * Pushes a value at the end of the active data.
+   * THIS DOES NOT PREVENT DUPPLICATE DATA
+   * @param value defines the object to push in the array.
+   */
+  push(t) {
+    super.push(t), t.__smartArrayFlags || (t.__smartArrayFlags = {}), t.__smartArrayFlags[this._id] = this._duplicateId;
+  }
+  /**
+   * Pushes a value at the end of the active data.
+   * If the data is already present, it won t be added again
+   * @param value defines the object to push in the array.
+   * @returns true if added false if it was already present
+   */
+  pushNoDuplicate(t) {
+    return t.__smartArrayFlags && t.__smartArrayFlags[this._id] === this._duplicateId ? !1 : (this.push(t), !0);
+  }
+  /**
+   * Resets the active data to an empty array.
+   */
+  reset() {
+    super.reset(), this._duplicateId++;
+  }
+  /**
+   * Concats the active data with a given array.
+   * This ensures no duplicate will be present in the result.
+   * @param array defines the data to concatenate with.
+   */
+  concatWithNoDuplicate(t) {
+    if (t.length !== 0) {
+      this.length + t.length > this.data.length && (this.data.length = (this.length + t.length) * 2);
+      for (let s = 0; s < t.length; s++) {
+        const i = (t.data || t)[s];
+        this.pushNoDuplicate(i);
+      }
+    }
+  }
+}
+export {
+  h as SmartArray,
+  n as SmartArrayNoDuplicate
+};

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

@@ -0,0 +1,129 @@
+class a {
+  constructor() {
+    this._count = 0, this._data = {};
+  }
+  /**
+   * This will clear this dictionary and copy the content from the 'source' one.
+   * If the T value is a custom object, it won't be copied/cloned, the same object will be used
+   * @param source the dictionary to take the content from and copy to this dictionary
+   */
+  copyFrom(t) {
+    this.clear(), t.forEach((n, r) => this.add(n, r));
+  }
+  /**
+   * Get a value based from its key
+   * @param key the given key to get the matching value from
+   * @returns the value if found, otherwise undefined is returned
+   */
+  get(t) {
+    const n = this._data[t];
+    if (n !== void 0)
+      return n;
+  }
+  /**
+   * Get a value from its key or add it if it doesn't exist.
+   * This method will ensure you that a given key/data will be present in the dictionary.
+   * @param key the given key to get the matching value from
+   * @param factory the factory that will create the value if the key is not present in the dictionary.
+   * The factory will only be invoked if there's no data for the given key.
+   * @returns the value corresponding to the key.
+   */
+  getOrAddWithFactory(t, n) {
+    let r = this.get(t);
+    return r !== void 0 || (r = n(t), r && this.add(t, r)), r;
+  }
+  /**
+   * Get a value from its key if present in the dictionary otherwise add it
+   * @param key the key to get the value from
+   * @param val if there's no such key/value pair in the dictionary add it with this value
+   * @returns the value corresponding to the key
+   */
+  getOrAdd(t, n) {
+    const r = this.get(t);
+    return r !== void 0 ? r : (this.add(t, n), n);
+  }
+  /**
+   * Check if there's a given key in the dictionary
+   * @param key the key to check for
+   * @returns true if the key is present, false otherwise
+   */
+  contains(t) {
+    return this._data[t] !== void 0;
+  }
+  /**
+   * Add a new key and its corresponding value
+   * @param key the key to add
+   * @param value the value corresponding to the key
+   * @returns true if the operation completed successfully, false if we couldn't insert the key/value because there was already this key in the dictionary
+   */
+  add(t, n) {
+    return this._data[t] !== void 0 ? !1 : (this._data[t] = n, ++this._count, !0);
+  }
+  /**
+   * Update a specific value associated to a key
+   * @param key defines the key to use
+   * @param value defines the value to store
+   * @returns true if the value was updated (or false if the key was not found)
+   */
+  set(t, n) {
+    return this._data[t] === void 0 ? !1 : (this._data[t] = n, !0);
+  }
+  /**
+   * Get the element of the given key and remove it from the dictionary
+   * @param key defines the key to search
+   * @returns the value associated with the key or null if not found
+   */
+  getAndRemove(t) {
+    const n = this.get(t);
+    return n !== void 0 ? (delete this._data[t], --this._count, n) : null;
+  }
+  /**
+   * Remove a key/value from the dictionary.
+   * @param key the key to remove
+   * @returns true if the item was successfully deleted, false if no item with such key exist in the dictionary
+   */
+  remove(t) {
+    return this.contains(t) ? (delete this._data[t], --this._count, !0) : !1;
+  }
+  /**
+   * Clear the whole content of the dictionary
+   */
+  clear() {
+    this._data = {}, this._count = 0;
+  }
+  /**
+   * Gets the current count
+   */
+  get count() {
+    return this._count;
+  }
+  /**
+   * Execute a callback on each key/val of the dictionary.
+   * Note that you can remove any element in this dictionary in the callback implementation
+   * @param callback the callback to execute on a given key/value pair
+   */
+  forEach(t) {
+    for (const n in this._data) {
+      const r = this._data[n];
+      t(n, r);
+    }
+  }
+  /**
+   * Execute a callback on every occurrence of the dictionary until it returns a valid TRes object.
+   * If the callback returns null or undefined the method will iterate to the next key/value pair
+   * Note that you can remove any element in this dictionary in the callback implementation
+   * @param callback the callback to execute, if it return a valid T instanced object the enumeration will stop and the object will be returned
+   * @returns the first item
+   */
+  first(t) {
+    for (const n in this._data) {
+      const r = this._data[n], e = t(n, r);
+      if (e)
+        return e;
+    }
+    return null;
+  }
+}
+export {
+  a as StringDictionary
+};

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

@@ -0,0 +1,26 @@
+const f = (e) => {
+  if (typeof TextDecoder < "u")
+    return new TextDecoder().decode(e);
+  let t = "";
+  for (let r = 0; r < e.byteLength; r++)
+    t += String.fromCharCode(e[r]);
+  return t;
+}, u = (e) => {
+  const t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  let r = "", c, n, i, d, l, h, s, o = 0;
+  const a = ArrayBuffer.isView(e) ? new Uint8Array(e.buffer, e.byteOffset, e.byteLength) : new Uint8Array(e);
+  for (; o < a.length; )
+    c = a[o++], n = o < a.length ? a[o++] : Number.NaN, i = o < a.length ? a[o++] : Number.NaN, d = c >> 2, l = (c & 3) << 4 | n >> 4, h = (n & 15) << 2 | i >> 6, s = i & 63, isNaN(n) ? h = s = 64 : isNaN(i) && (s = 64), r += t.charAt(d) + t.charAt(l) + t.charAt(h) + t.charAt(s);
+  return r;
+}, y = (e) => atob(e), A = (e) => {
+  const t = y(e), r = t.length, c = new Uint8Array(new ArrayBuffer(r));
+  for (let n = 0; n < r; n++)
+    c[n] = t.charCodeAt(n);
+  return c.buffer;
+};
+export {
+  f as Decode,
+  A as DecodeBase64ToBinary,
+  y as DecodeBase64ToString,
+  u as EncodeArrayBufferToBase64
+};

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

@@ -0,0 +1,97 @@
+import { AndOrNotEvaluator as n } from "./andOrNotEvaluator.esm.js";
+class r {
+  /**
+   * Adds support for tags on the given object
+   * @param obj defines the object to use
+   */
+  static EnableFor(t) {
+    t._tags = t._tags || {}, t.hasTags = () => r.HasTags(t), t.addTags = (e) => r.AddTagsTo(t, e), t.removeTags = (e) => r.RemoveTagsFrom(t, e), t.matchesTagsQuery = (e) => r.MatchesQuery(t, e);
+  }
+  /**
+   * Removes tags support
+   * @param obj defines the object to use
+   */
+  static DisableFor(t) {
+    delete t._tags, delete t.hasTags, delete t.addTags, delete t.removeTags, delete t.matchesTagsQuery;
+  }
+  /**
+   * Gets a boolean indicating if the given object has tags
+   * @param obj defines the object to use
+   * @returns a boolean
+   */
+  static HasTags(t) {
+    if (!t._tags)
+      return !1;
+    const e = t._tags;
+    for (const s in e)
+      if (Object.prototype.hasOwnProperty.call(e, s))
+        return !0;
+    return !1;
+  }
+  /**
+   * Gets the tags available on a given object
+   * @param obj defines the object to use
+   * @param asString defines if the tags must be returned as a string instead of an array of strings
+   * @returns the tags
+   */
+  static GetTags(t, e = !0) {
+    if (!t._tags)
+      return null;
+    if (e) {
+      const s = [];
+      for (const a in t._tags)
+        Object.prototype.hasOwnProperty.call(t._tags, a) && t._tags[a] === !0 && s.push(a);
+      return s.join(" ");
+    } else
+      return t._tags;
+  }
+  /**
+   * Adds tags to an object
+   * @param obj defines the object to use
+   * @param tagsString defines the tag string. The tags 'true' and 'false' are reserved and cannot be used as tags.
+   * A tag cannot start with '||', '&&', and '!'. It cannot contain whitespaces
+   */
+  static AddTagsTo(t, e) {
+    if (!e || typeof e != "string")
+      return;
+    e.split(" ").forEach(function(a) {
+      r._AddTagTo(t, a);
+    });
+  }
+  /**
+   * @internal
+   */
+  static _AddTagTo(t, e) {
+    e = e.trim(), !(e === "" || e === "true" || e === "false") && (e.match(/[\s]/) || e.match(/^([!]|([|]|[&]){2})/) || (r.EnableFor(t), t._tags[e] = !0));
+  }
+  /**
+   * Removes specific tags from a specific object
+   * @param obj defines the object to use
+   * @param tagsString defines the tags to remove
+   */
+  static RemoveTagsFrom(t, e) {
+    if (!r.HasTags(t))
+      return;
+    const s = e.split(" ");
+    for (const a in s)
+      r._RemoveTagFrom(t, s[a]);
+  }
+  /**
+   * @internal
+   */
+  static _RemoveTagFrom(t, e) {
+    delete t._tags[e];
+  }
+  /**
+   * Defines if tags hosted on an object match a given query
+   * @param obj defines the object to use
+   * @param tagsQuery defines the tag query
+   * @returns a boolean
+   */
+  static MatchesQuery(t, e) {
+    return e === void 0 ? !0 : e === "" ? r.HasTags(t) : n.Eval(e, (s) => r.HasTags(t) && t._tags[s]);
+  }
+}
+export {
+  r as Tags
+};