@vc-shell/framework 1.1.46 → 1.1.47

package/dist/vendor-cypress-signalr-mock-CdKwIhWw.js

@@ -0,0 +1,769 @@
+var B = Object.defineProperty, G = (e, t, r) => t in e ? B(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r, h = (e, t, r) => (G(e, typeof t != "symbol" ? t + "" : t, r), r);
+class c {
+  static debug(t) {
+    this._logLevel >= 4 && console.debug(this._prefix + t);
+  }
+  static info(t, r = void 0) {
+    this._logLevel >= 3 && console.info(this._prefix + t, r);
+  }
+  static warn(t) {
+    this._logLevel >= 1 && console.warn(this._prefix + t);
+  }
+  static error(t, r = !0) {
+    if (this._logLevel >= 0) {
+      if (r)
+        throw new Error(this._prefix + t);
+      console.error(this._prefix + t);
+    }
+  }
+  static setLogLevel(t) {
+    this._logLevel = t;
+  }
+}
+h(c, "_prefix", "[Cypress-SignalR-Mock] - "), h(c, "_logLevel", 3);
+var C = function(e, t) {
+  return C = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var o in n)
+      Object.prototype.hasOwnProperty.call(n, o) && (r[o] = n[o]);
+  }, C(e, t);
+};
+function y(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  C(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+function S(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], n = 0;
+  if (r)
+    return r.call(e);
+  if (e && typeof e.length == "number")
+    return {
+      next: function() {
+        return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+      }
+    };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function x(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r)
+    return e;
+  var n = r.call(e), o, i = [], s;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(o = n.next()).done; )
+      i.push(o.value);
+  } catch (u) {
+    s = { error: u };
+  } finally {
+    try {
+      o && !o.done && (r = n.return) && r.call(n);
+    } finally {
+      if (s)
+        throw s.error;
+    }
+  }
+  return i;
+}
+function O(e, t, r) {
+  if (arguments.length === 2)
+    for (var n = 0, o = t.length, i; n < o; n++)
+      (i || !(n in t)) && (i || (i = Array.prototype.slice.call(t, 0, n)), i[n] = t[n]);
+  return e.concat(i || Array.prototype.slice.call(t));
+}
+function f(e) {
+  return typeof e == "function";
+}
+function F(e) {
+  var t = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, r = e(t);
+  return r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r;
+}
+var g = F(function(e) {
+  return function(t) {
+    e(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(r, n) {
+      return n + 1 + ") " + r.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function P(e, t) {
+  if (e) {
+    var r = e.indexOf(t);
+    0 <= r && e.splice(r, 1);
+  }
+}
+var m = function() {
+  function e(t) {
+    this.initialTeardown = t, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t, r, n, o, i;
+    if (!this.closed) {
+      this.closed = !0;
+      var s = this._parentage;
+      if (s)
+        if (this._parentage = null, Array.isArray(s))
+          try {
+            for (var u = S(s), a = u.next(); !a.done; a = u.next()) {
+              var w = a.value;
+              w.remove(this);
+            }
+          } catch (l) {
+            t = { error: l };
+          } finally {
+            try {
+              a && !a.done && (r = u.return) && r.call(u);
+            } finally {
+              if (t)
+                throw t.error;
+            }
+          }
+        else
+          s.remove(this);
+      var j = this.initialTeardown;
+      if (f(j))
+        try {
+          j();
+        } catch (l) {
+          i = l instanceof g ? l.errors : [l];
+        }
+      var D = this._finalizers;
+      if (D) {
+        this._finalizers = null;
+        try {
+          for (var b = S(D), p = b.next(); !p.done; p = b.next()) {
+            var q = p.value;
+            try {
+              L(q);
+            } catch (l) {
+              i = i ?? [], l instanceof g ? i = O(O([], x(i)), x(l.errors)) : i.push(l);
+            }
+          }
+        } catch (l) {
+          n = { error: l };
+        } finally {
+          try {
+            p && !p.done && (o = b.return) && o.call(b);
+          } finally {
+            if (n)
+              throw n.error;
+          }
+        }
+      }
+      if (i)
+        throw new g(i);
+    }
+  }, e.prototype.add = function(t) {
+    var r;
+    if (t && t !== this)
+      if (this.closed)
+        L(t);
+      else {
+        if (t instanceof e) {
+          if (t.closed || t._hasParent(this))
+            return;
+          t._addParent(this);
+        }
+        (this._finalizers = (r = this._finalizers) !== null && r !== void 0 ? r : []).push(t);
+      }
+  }, e.prototype._hasParent = function(t) {
+    var r = this._parentage;
+    return r === t || Array.isArray(r) && r.includes(t);
+  }, e.prototype._addParent = function(t) {
+    var r = this._parentage;
+    this._parentage = Array.isArray(r) ? (r.push(t), r) : r ? [r, t] : t;
+  }, e.prototype._removeParent = function(t) {
+    var r = this._parentage;
+    r === t ? this._parentage = null : Array.isArray(r) && P(r, t);
+  }, e.prototype.remove = function(t) {
+    var r = this._finalizers;
+    r && P(r, t), t instanceof e && t._removeParent(this);
+  }, e.EMPTY = function() {
+    var t = new e();
+    return t.closed = !0, t;
+  }(), e;
+}(), M = m.EMPTY;
+function R(e) {
+  return e instanceof m || e && "closed" in e && f(e.remove) && f(e.add) && f(e.unsubscribe);
+}
+function L(e) {
+  f(e) ? e() : e.unsubscribe();
+}
+var J = {
+  Promise: void 0
+}, K = {
+  setTimeout: function(e, t) {
+    for (var r = [], n = 2; n < arguments.length; n++)
+      r[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, O([e, t], x(r)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function W(e) {
+  K.setTimeout(function() {
+    throw e;
+  });
+}
+function A() {
+}
+function v(e) {
+  e();
+}
+var H = function(e) {
+  y(t, e);
+  function t(r) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, r ? (n.destination = r, R(r) && r.add(n)) : n.destination = Q, n;
+  }
+  return t.create = function(r, n, o) {
+    return new k(r, n, o);
+  }, t.prototype.next = function(r) {
+    this.isStopped || this._next(r);
+  }, t.prototype.error = function(r) {
+    this.isStopped || (this.isStopped = !0, this._error(r));
+  }, t.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, t.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, t.prototype._next = function(r) {
+    this.destination.next(r);
+  }, t.prototype._error = function(r) {
+    try {
+      this.destination.error(r);
+    } finally {
+      this.unsubscribe();
+    }
+  }, t.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, t;
+}(m), X = function() {
+  function e(t) {
+    this.partialObserver = t;
+  }
+  return e.prototype.next = function(t) {
+    var r = this.partialObserver;
+    if (r.next)
+      try {
+        r.next(t);
+      } catch (n) {
+        d(n);
+      }
+  }, e.prototype.error = function(t) {
+    var r = this.partialObserver;
+    if (r.error)
+      try {
+        r.error(t);
+      } catch (n) {
+        d(n);
+      }
+    else
+      d(t);
+  }, e.prototype.complete = function() {
+    var t = this.partialObserver;
+    if (t.complete)
+      try {
+        t.complete();
+      } catch (r) {
+        d(r);
+      }
+  }, e;
+}(), k = function(e) {
+  y(t, e);
+  function t(r, n, o) {
+    var i = e.call(this) || this, s;
+    return f(r) || !r ? s = {
+      next: r ?? void 0,
+      error: n ?? void 0,
+      complete: o ?? void 0
+    } : s = r, i.destination = new X(s), i;
+  }
+  return t;
+}(H);
+function d(e) {
+  W(e);
+}
+function Z(e) {
+  throw e;
+}
+var Q = {
+  closed: !0,
+  next: A,
+  error: Z,
+  complete: A
+}, tt = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function rt(e) {
+  return e;
+}
+function et(e) {
+  return e.length === 0 ? rt : e.length === 1 ? e[0] : function(t) {
+    return e.reduce(function(r, n) {
+      return n(r);
+    }, t);
+  };
+}
+var I = function() {
+  function e(t) {
+    t && (this._subscribe = t);
+  }
+  return e.prototype.lift = function(t) {
+    var r = new e();
+    return r.source = this, r.operator = t, r;
+  }, e.prototype.subscribe = function(t, r, n) {
+    var o = this, i = ot(t) ? t : new k(t, r, n);
+    return v(function() {
+      var s = o, u = s.operator, a = s.source;
+      i.add(u ? u.call(i, a) : a ? o._subscribe(i) : o._trySubscribe(i));
+    }), i;
+  }, e.prototype._trySubscribe = function(t) {
+    try {
+      return this._subscribe(t);
+    } catch (r) {
+      t.error(r);
+    }
+  }, e.prototype.forEach = function(t, r) {
+    var n = this;
+    return r = $(r), new r(function(o, i) {
+      var s = new k({
+        next: function(u) {
+          try {
+            t(u);
+          } catch (a) {
+            i(a), s.unsubscribe();
+          }
+        },
+        error: i,
+        complete: o
+      });
+      n.subscribe(s);
+    });
+  }, e.prototype._subscribe = function(t) {
+    var r;
+    return (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(t);
+  }, e.prototype[tt] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var t = [], r = 0; r < arguments.length; r++)
+      t[r] = arguments[r];
+    return et(t)(this);
+  }, e.prototype.toPromise = function(t) {
+    var r = this;
+    return t = $(t), new t(function(n, o) {
+      var i;
+      r.subscribe(function(s) {
+        return i = s;
+      }, function(s) {
+        return o(s);
+      }, function() {
+        return n(i);
+      });
+    });
+  }, e.create = function(t) {
+    return new e(t);
+  }, e;
+}();
+function $(e) {
+  var t;
+  return (t = e ?? J.Promise) !== null && t !== void 0 ? t : Promise;
+}
+function nt(e) {
+  return e && f(e.next) && f(e.error) && f(e.complete);
+}
+function ot(e) {
+  return e && e instanceof H || nt(e) && R(e);
+}
+var it = F(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), T = function(e) {
+  y(t, e);
+  function t() {
+    var r = e.call(this) || this;
+    return r.closed = !1, r.currentObservers = null, r.observers = [], r.isStopped = !1, r.hasError = !1, r.thrownError = null, r;
+  }
+  return t.prototype.lift = function(r) {
+    var n = new z(this, this);
+    return n.operator = r, n;
+  }, t.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new it();
+  }, t.prototype.next = function(r) {
+    var n = this;
+    v(function() {
+      var o, i;
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.currentObservers || (n.currentObservers = Array.from(n.observers));
+        try {
+          for (var s = S(n.currentObservers), u = s.next(); !u.done; u = s.next()) {
+            var a = u.value;
+            a.next(r);
+          }
+        } catch (w) {
+          o = { error: w };
+        } finally {
+          try {
+            u && !u.done && (i = s.return) && i.call(s);
+          } finally {
+            if (o)
+              throw o.error;
+          }
+        }
+      }
+    });
+  }, t.prototype.error = function(r) {
+    var n = this;
+    v(function() {
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.hasError = n.isStopped = !0, n.thrownError = r;
+        for (var o = n.observers; o.length; )
+          o.shift().error(r);
+      }
+    });
+  }, t.prototype.complete = function() {
+    var r = this;
+    v(function() {
+      if (r._throwIfClosed(), !r.isStopped) {
+        r.isStopped = !0;
+        for (var n = r.observers; n.length; )
+          n.shift().complete();
+      }
+    });
+  }, t.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(t.prototype, "observed", {
+    get: function() {
+      var r;
+      return ((r = this.observers) === null || r === void 0 ? void 0 : r.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), t.prototype._trySubscribe = function(r) {
+    return this._throwIfClosed(), e.prototype._trySubscribe.call(this, r);
+  }, t.prototype._subscribe = function(r) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(r), this._innerSubscribe(r);
+  }, t.prototype._innerSubscribe = function(r) {
+    var n = this, o = this, i = o.hasError, s = o.isStopped, u = o.observers;
+    return i || s ? M : (this.currentObservers = null, u.push(r), new m(function() {
+      n.currentObservers = null, P(u, r);
+    }));
+  }, t.prototype._checkFinalizedStatuses = function(r) {
+    var n = this, o = n.hasError, i = n.thrownError, s = n.isStopped;
+    o ? r.error(i) : s && r.complete();
+  }, t.prototype.asObservable = function() {
+    var r = new I();
+    return r.source = this, r;
+  }, t.create = function(r, n) {
+    return new z(r, n);
+  }, t;
+}(I), z = function(e) {
+  y(t, e);
+  function t(r, n) {
+    var o = e.call(this) || this;
+    return o.destination = r, o.source = n, o;
+  }
+  return t.prototype.next = function(r) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.next) === null || o === void 0 || o.call(n, r);
+  }, t.prototype.error = function(r) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.error) === null || o === void 0 || o.call(n, r);
+  }, t.prototype.complete = function() {
+    var r, n;
+    (n = (r = this.destination) === null || r === void 0 ? void 0 : r.complete) === null || n === void 0 || n.call(r);
+  }, t.prototype._subscribe = function(r) {
+    var n, o;
+    return (o = (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(r)) !== null && o !== void 0 ? o : M;
+  }, t;
+}(T);
+class st {
+  constructor(t, r) {
+    this._subject = t, this._observer = r;
+  }
+  dispose() {
+    const t = this._subject.observers.indexOf(this._observer);
+    t > -1 && this._subject.observers.splice(t, 1), this._subject.observers.length === 0 && this._subject.cancelCallback && this._subject.cancelCallback().catch((r) => {
+    });
+  }
+}
+class ut {
+  constructor() {
+    this.observers = [];
+  }
+  next(t) {
+    for (const r of this.observers)
+      r.next(t);
+  }
+  error(t) {
+    for (const r of this.observers)
+      r.error && r.error(t);
+  }
+  complete() {
+    for (const t of this.observers)
+      t.complete && t.complete();
+  }
+  subscribe(t) {
+    return this.observers.push(t), new st(this, t);
+  }
+}
+class ct {
+  constructor(t) {
+    h(this, "_hubConnectionData", []), h(this, "_serverInvokes", []), h(this, "name"), this.name = t;
+  }
+  publish(t, r) {
+    t = t.toLowerCase();
+    const n = this._hubConnectionData.filter(
+      (o) => o.messageType === t
+    );
+    if (n.length === 0) {
+      c.warn(`No subscribers for ${t}`);
+      return;
+    }
+    c.debug(
+      `Publishing action: ${t} to ${n.length} subscribers`
+    ), n.forEach((o) => {
+      o.channel.next({ name: t, value: r });
+    });
+  }
+  verify(t, r) {
+    t = t.toLowerCase();
+    const n = this._serverInvokes.filter(
+      (o) => o.action === t
+    );
+    r && r(n);
+  }
+  on(t, r) {
+    t = t.toLowerCase(), this._hubConnectionData.some((i) => i.messageType === t) || this._hubConnectionData.push({
+      messageType: t,
+      isStream: !1,
+      channel: new T(),
+      subscriptions: []
+    });
+    let n = this._hubConnectionData.find(
+      (i) => i.messageType === t
+    );
+    if (!n)
+      throw new Error(`Could not find connection data for ${t}`);
+    let o = n.channel.subscribe((i) => {
+      r(i.value);
+    });
+    n.subscriptions.push({
+      handler: r,
+      subscription: o
+    });
+  }
+  /** Invokes a streaming hub method on the server using the specified name and arguments.
+   *
+   * @typeparam T The type of the items returned by the server.
+   * @param {string} methodName The name of the server method to invoke.
+   * @param {any[]} args The arguments used to invoke the server method.
+   * @returns {IStreamResult<T>} An object that yields results from the server as they are received.
+   */
+  // @ts-ignore
+  stream(t, ...r) {
+    t = t.toLowerCase(), this._hubConnectionData.some((i) => i.messageType === t) || this._hubConnectionData.push({
+      messageType: t,
+      isStream: !0,
+      channel: new T(),
+      subscriptions: []
+    });
+    let n = this._hubConnectionData.find(
+      (i) => i.messageType === t
+    );
+    if (!n)
+      throw new Error(`Could not find connection data for ${t}`);
+    const o = new ut();
+    return n.channel.subscribe({
+      next: (i) => o.next(i),
+      error: (i) => o.error(i),
+      complete: () => o.complete()
+    }), o;
+  }
+  /** Invokes a hub method on the server using the specified name and arguments.
+   *
+   * The Promise returned by this method resolves when the server indicates it has finished invoking the method. When the promise
+   * resolves, the server has finished invoking the method. If the server method returns a result, it is produced as the result of
+   * resolving the Promise.
+   *
+   * @typeparam T The expected return type.
+   * @param {string} methodName The name of the server method to invoke.
+   * @param {any[]} args The arguments used to invoke the server method.
+   * @returns {Promise<T>} A Promise that resolves with the result of the server method (if any), or rejects with an error.
+   */
+  invoke(t, ...r) {
+    return new Promise((n) => {
+      this._serverInvokes.push({
+        action: t,
+        args: r
+      }), n(0);
+    });
+  }
+  off(t, r) {
+    t = t.toLowerCase();
+    const n = this._hubConnectionData.findIndex(
+      (o) => o.messageType === t
+    );
+    if (n == -1) {
+      c.warn(`No channels registered for action name: ${t}`);
+      return;
+    }
+    if (r) {
+      const o = this._hubConnectionData[n].subscriptions.findIndex((i) => i.handler === r);
+      if (o == -1) {
+        c.warn(
+          `Could not find the handler to delete for action name: ${t}`
+        );
+        return;
+      }
+      this._hubConnectionData[n].subscriptions.splice(o, 1), this._hubConnectionData[n].subscriptions.length === 0 && this._hubConnectionData.splice(n, 1);
+    } else
+      this._hubConnectionData.splice(n, 1);
+  }
+  /** Registers a handler that will be invoked when the connection is closed.
+   *
+   * @param {Function} callback The handler that will be invoked when the connection is closed. Optionally receives a single argument containing the error that caused the connection to close (if any).
+   */
+  // @ts-ignore
+  onclose(t) {
+  }
+  /** Starts the connection.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the connection has been successfully established, or rejects with an error.
+   */
+  start() {
+    return Promise.resolve();
+  }
+  /** Stops the connection.
+   *
+   * @returns {Promise<void>} A Promise that resolves when the connection has been successfully terminated, or rejects with an error.
+   */
+  async stop() {
+    return Promise.resolve();
+  }
+  /** Registers a handler that will be invoked when the connection starts reconnecting.
+   *
+   * @param {Function} callback The handler that will be invoked when the connection starts reconnecting. Optionally receives a single argument containing the error that caused the connection to start reconnecting (if any).
+   */
+  // @ts-ignore
+  onreconnecting(t) {
+  }
+  /** Registers a handler that will be invoked when the connection successfully reconnects.
+   *
+   * @param {Function} callback The handler that will be invoked when the connection successfully reconnects.
+   */
+  // @ts-ignore
+  onreconnected(t) {
+  }
+  /** Invokes a hub method on the server using the specified name and arguments. Does not wait for a response from the receiver.
+   *
+   * The Promise returned by this method resolves when the client has sent the invocation to the server. The server may still
+   * be processing the invocation.
+   *
+   * @param {string} methodName The name of the server method to invoke.
+   * @param {any[]} args The arguments used to invoke the server method.
+   * @returns {Promise<void>} A Promise that resolves when the invocation has been successfully sent, or rejects with an error.
+   */
+  // @ts-ignore
+  send(t, ...r) {
+    return Promise.resolve();
+  }
+  // endregion
+}
+function N() {
+  return E() ? !1 : window.hasOwnProperty("Cypress");
+}
+function _() {
+  return !E() && window["cypress-signalr-mock"] ? window["cypress-signalr-mock"] : (U(), _());
+}
+function at(e) {
+  E() || (window["cypress-signalr-mock"] = e);
+}
+function U() {
+  at(lt());
+}
+function lt() {
+  return {
+    mocks: []
+  };
+}
+function Y(e) {
+  return _().mocks.find((t) => t.name === e) ?? null;
+}
+function E() {
+  return typeof window > "u" ? (c.error(
+    "window is not defined. This most likely happens during SSR, which is not supported",
+    !1
+  ), !0) : !1;
+}
+function V() {
+  var e;
+  return typeof process < "u" && ((e = process == null ? void 0 : process.env) == null ? void 0 : e.hasOwnProperty("VITEST")) && process.env.VITEST === "true";
+}
+function ft() {
+  if (!N()) {
+    c.debug("Cypress is not running, skipping setup of Cypress commands");
+    return;
+  }
+  const e = window.Cypress;
+  e.Commands.add("hubPublish", pt), e.Commands.add("hubVerifyInvokes", ht), e.Commands.add("hubClear", dt), e.Commands.add("hubPrintData", bt);
+}
+function pt(e, t, r) {
+  const n = Y(e);
+  if (!n) {
+    c.error(`[cy.hubPublish] - HubConnectionMock not found for ${e}`);
+    return;
+  }
+  n.publish(t, r);
+}
+function ht(e, t, r) {
+  const n = Y(e);
+  if (!n) {
+    c.error(
+      `[cy.hubVerify] - HubConnectionMock not found for hub with name: ${e}`
+    );
+    return;
+  }
+  n.verify(t, r);
+}
+function bt() {
+  c.info(
+    'Current window["cypress-signalr-mock"] data:',
+    _()
+  );
+}
+function dt() {
+  U();
+}
+ft();
+vt("default");
+function vt(e, {
+  debug: t,
+  enableForVitest: r
+} = {}) {
+  if (t && c.setLogLevel(4), !r && V() && c.info(
+    `Vitest is running but 'enableForVitest' is ${r}, skip enabling CypressSignalRMock...`
+  ), N() || r && V()) {
+    const n = new ct(e);
+    return _().mocks.push(n), n;
+  }
+  return null;
+}
+export {
+  vt as _
+};