ranuts 0.4.1-alpha.1 → 0.5.0

package/dist/src/utils/monitor.js

@@ -0,0 +1,84 @@
+import { noop as c } from "./noop.js";
+import { handleConsole as a } from "./console.js";
+import { handleError as l } from "./error.js";
+import { getPerformance as d } from "./performance.js";
+import { createData as t, report as o, setReportUrl as f } from "./report.js";
+import { handleFetchHook as u, handleXhrHook as m } from "./request.js";
+import { throttle as k } from "./throttle.js";
+import { handleClick as v } from "./behavior.js";
+var g = {
+  click: !0,
+  error: !0,
+  fetch: !0,
+  xhr: !0,
+  performance: !0,
+  console: !1
+}, q = class {
+  options;
+  teardown = [];
+  send = c;
+  constructor(e) {
+    this.options = e, f({
+      url: e.url,
+      userIdCookie: e.userIdCookie
+    }), this.send = k((r) => o(r), e.throttleMs ?? 300);
+  }
+  get running() {
+    return this.teardown.length > 0;
+  }
+  start = () => {
+    if (this.running) return this.stop;
+    const e = {
+      ...g,
+      ...this.options.channels
+    };
+    return e.performance && this.reportPerformance(), e.click && this.teardown.push(this.reportClick()), e.error && this.teardown.push(this.reportError()), e.fetch && this.teardown.push(this.reportFetch()), e.xhr && this.teardown.push(this.reportXhr()), e.console && this.teardown.push(this.reportConsole()), this.stop;
+  };
+  stop = () => {
+    const e = this.teardown.splice(0, this.teardown.length);
+    for (const r of e) r();
+  };
+  event = (e, r) => ({ payload: {
+    ...t(),
+    data: r,
+    type: e
+  } });
+  log = (e) => {
+    this.send({ payload: {
+      ...t(),
+      ...e
+    } });
+  };
+  reportPerformance = () => {
+    o({ payload: {
+      ...d(),
+      ...t(),
+      type: "performance"
+    } });
+  };
+  reportClick = () => v((r) => {
+    const { pageX: s, pageY: n, screenX: h, screenY: i, type: p } = r;
+    this.send(this.event("click", {
+      pageX: s,
+      pageY: n,
+      screenX: h,
+      screenY: i,
+      type: p
+    }));
+  });
+  reportError = () => l((...e) => this.send(this.event("error", { ...e })));
+  reportFetch = () => u({
+    requestHook: (...e) => this.send(this.event("fetchRequest", { ...e })),
+    responseHook: (...e) => this.send(this.event("fetchResponse", { ...e })),
+    errorHook: (...e) => this.send(this.event("fetchError", { ...e }))
+  });
+  reportXhr = () => m({
+    requestHook: (...e) => this.send(this.event("xhrRequest", { ...e })),
+    responseHook: (...e) => this.send(this.event("xhrResponse", { ...e })),
+    errorHook: (...e) => this.send(this.event("xhrError", { ...e }))
+  });
+  reportConsole = () => a((...e) => this.send(this.event("console", { ...e })));
+};
+export {
+  q as Monitor
+};

package/dist/src/utils/network.js

@@ -0,0 +1,117 @@
+var n = /* @__PURE__ */ new Map([
+  [100, "Continue"],
+  [101, "Switching Protocols"],
+  [102, "Processing"],
+  [103, "Early Hints"],
+  [200, "OK"],
+  [201, "Created"],
+  [202, "Accepted"],
+  [203, "Non-Authoritative Information"],
+  [204, "No Content"],
+  [205, "Reset Content"],
+  [206, "Partial Content"],
+  [207, "Multi-Status"],
+  [208, "Already Reported"],
+  [226, "IM Used"],
+  [300, "Multiple Choices"],
+  [301, "Moved Permanently"],
+  [302, "Found"],
+  [303, "See Other"],
+  [304, "Not Modified"],
+  [305, "Use Proxy"],
+  [307, "Temporary Redirect"],
+  [308, "Permanent Redirect"],
+  [400, "Bad Request"],
+  [401, "Unauthorized"],
+  [402, "Payment Required"],
+  [403, "Forbidden"],
+  [404, "Not Found"],
+  [405, "Method Not Allowed"],
+  [406, "Not Acceptable"],
+  [407, "Proxy Authentication Required"],
+  [408, "Request Timeout"],
+  [409, "Conflict"],
+  [410, "Gone"],
+  [411, "Length Required"],
+  [412, "Precondition Failed"],
+  [413, "Payload Too Large"],
+  [414, "URI Too Long"],
+  [415, "Unsupported Media Type"],
+  [416, "Range Not Satisfiable"],
+  [417, "Expectation Failed"],
+  [418, "I'm a Teapot"],
+  [421, "Misdirected Request"],
+  [422, "Unprocessable Entity"],
+  [423, "Locked"],
+  [424, "Failed Dependency"],
+  [425, "Too Early"],
+  [426, "Upgrade Required"],
+  [428, "Precondition Required"],
+  [429, "Too Many Requests"],
+  [431, "Request Header Fields Too Large"],
+  [451, "Unavailable For Legal Reasons"],
+  [500, "Internal Server Error"],
+  [501, "Not Implemented"],
+  [502, "Bad Gateway"],
+  [503, "Service Unavailable"],
+  [504, "Gateway Timeout"],
+  [505, "HTTP Version Not Supported"],
+  [506, "Variant Also Negotiates"],
+  [507, "Insufficient Storage"],
+  [508, "Loop Detected"],
+  [509, "Bandwidth Limit Exceeded"],
+  [510, "Not Extended"],
+  [511, "Network Authentication Required"]
+]), o = {
+  message: n,
+  code: i(n),
+  codes: u(n),
+  redirect: {
+    300: !0,
+    301: !0,
+    302: !0,
+    303: !0,
+    305: !0,
+    307: !0,
+    308: !0
+  },
+  empty: {
+    204: !0,
+    205: !0,
+    304: !0
+  },
+  retry: {
+    502: !0,
+    503: !0,
+    504: !0
+  }
+};
+function i(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const [r, a] of e) t.set(a.toLowerCase(), r);
+  return t;
+}
+function u(e) {
+  const t = [];
+  for (const [r, a] of e) t.push(r);
+  return t;
+}
+function d(e) {
+  const t = e.toLowerCase();
+  if (o.code.has(t), !o.code.has(t)) throw new Error('invalid status message: "' + e + '"');
+  return o.code.get(t);
+}
+function s(e) {
+  if (!o.message.has(e)) throw new Error("invalid status code: " + e);
+  return o.message.get(e);
+}
+function c(e) {
+  if (typeof e == "number") return s(e);
+  if (typeof e != "string") throw new TypeError("code must be a number or string");
+  const t = parseInt(e, 10);
+  return !isNaN(t) && o.codes.includes(t) ? s(t) : d(e);
+}
+export {
+  c as getStatus,
+  o as status
+};

package/dist/src/utils/noop.js

@@ -0,0 +1,5 @@
+var o = () => {
+};
+export {
+  o as noop
+};

package/dist/src/utils/number.d.ts

@@ -139,4 +139,24 @@ export declare const linearstep: (edge0: number, edge1: number, x: number) => nu
  * @return {number}
  */
 export declare const smoothstep: (edge0: number, edge1: number, x: number) => number;
+/**
+ * @description: Format a byte count for a person to read.
+ *
+ * Steps in units of 1024 and keeps one decimal from KB up, because "1.4 MB" is the number a
+ * file manager shows for the same file and a reader comparing the two should not have to
+ * wonder. Bytes get no decimal — a fraction of a byte is not a thing.
+ *
+ * @param {number} bytes Byte count. Negative or non-finite input yields `'0 B'`, since there
+ * is no honest reading of a file with a negative size.
+ * @return {string}
+ * @example
+ * ```ts
+ * formatBytes(0);        // '0 B'
+ * formatBytes(999);      // '999 B'
+ * formatBytes(1024);     // '1.0 KB'
+ * formatBytes(1536);     // '1.5 KB'
+ * formatBytes(1048576);  // '1.0 MB'
+ * ```
+ */
+export declare const formatBytes: (bytes: number) => string;
 export {};

package/dist/src/utils/number.js

@@ -0,0 +1,185 @@
+import { toHalfWidth as v, toString as u } from "./str.js";
+var C = (e = "") => {
+  if (e.length === 0) return 0;
+  if (e.endsWith("%")) {
+    const t = Number(e.replace("%", ""));
+    return t > 1 ? t / 100 : t;
+  } else return Number(e);
+}, L = (e, t = 0, r = 1) => Math.min(r, Math.max(t, e)), g = class M {
+  getDecimalLength = (t) => {
+    const [r, n] = t.toString().split(".");
+    return n ? n.length : 0;
+  };
+  amend = (t, r = 15) => parseFloat(Number(t).toPrecision(r));
+  power = (t, r) => Math.pow(10, Math.max(this.getDecimalLength(t), this.getDecimalLength(r)));
+  static handleMethod = (t, r) => {
+    const { power: n, amend: s } = new M(), i = n(t, r), a = s(t * i), o = s(r * i);
+    return (h) => {
+      switch (h) {
+        case "+":
+          return (a + o) / i;
+        case "-":
+          return (a - o) / i;
+        case "*":
+          return a * o / (i * i);
+        case "/":
+          return a / o;
+      }
+    };
+  };
+  static add = (t, r) => this.handleMethod(t, r)("+");
+  static divide = (t, r) => this.handleMethod(t, r)("/");
+  static multiply = (t, r) => this.handleMethod(t, r)("*");
+  static subtract = (t, r) => this.handleMethod(t, r)("-");
+};
+function x(e, t, r) {
+  function n(o) {
+    const [h, c] = o.toString().split(".");
+    return c ? c.length : 0;
+  }
+  const s = (o, h = 15) => parseFloat(Number(o).toPrecision(h)), i = Math.pow(10, Math.max(n(e), n(r)));
+  let a = 0;
+  switch (e = s(e * i), r = s(r * i), t) {
+    case "+":
+      a = (e + r) / i;
+      break;
+    case "-":
+      a = (e - r) / i;
+      break;
+    case "*":
+      a = e * r / (i * i);
+      break;
+    case "/":
+      a = e / r;
+  }
+  return a = s(a), {
+    result: a,
+    next: (o, h) => x(a, o, h)
+  };
+}
+var $ = (e, t = "zh-CN", r = 2, n = 2) => {
+  let s = [
+    "",
+    "K",
+    "M",
+    "B",
+    "T"
+  ], i = 3;
+  if (t === "zh-CN" && (s = [
+    "",
+    " 万",
+    " 亿",
+    " 万亿"
+  ], i = 4), t === "zh-HK" && (s = [
+    "",
+    " 萬",
+    " 億",
+    " 萬億"
+  ], i = 4), !/^[+-]?\d+(?:\.\d+)?$/.test(e)) return "--";
+  const a = parseInt(e).toString().length, o = Math.min(Math.floor((a - 1) / i), s.length - 1), h = g.divide(Number(e), 10 ** (o * i))?.toFixed(r);
+  return Number(h).toFixed(n) + s[o];
+}, D = (e, t) => u(e).startsWith("+") || u(e).startsWith("-") ? u(e) : t ? Number(t || 0) > 0 ? `+${u(e)}` : u(e) : Number(e || 0) > 0 ? `+${u(e)}` : u(e), l = {
+  零: 0,
+  "〇": 0,
+  一: 1,
+  二: 2,
+  两: 2,
+  三: 3,
+  四: 4,
+  五: 5,
+  六: 6,
+  七: 7,
+  八: 8,
+  九: 9
+}, m = {
+  十: 10,
+  百: 100,
+  千: 1e3
+}, T = (e) => {
+  const t = v(e.trim());
+  if (/^\d+$/.test(t)) return Number.parseInt(t, 10);
+  if (t.length === 0) return null;
+  let r = 0, n = 0, s = 0;
+  for (const i of t) if (l[i] !== void 0) s = l[i];
+  else if (m[i] !== void 0)
+    n += (s || (i === "十" ? 1 : 0)) * m[i], s = 0;
+  else if (i === "万" || i === "萬")
+    r = (r + n + s) * 1e4, n = 0, s = 0;
+  else return null;
+  return r + n + s;
+}, d = {
+  I: 1,
+  V: 5,
+  X: 10,
+  L: 50,
+  C: 100,
+  D: 500,
+  M: 1e3
+}, w = (e) => {
+  const t = e.trim().toUpperCase();
+  if (!/^[IVXLCDM]+$/.test(t)) return null;
+  let r = 0;
+  for (let n = 0; n < t.length; n++) {
+    const s = d[t[n]], i = d[t[n + 1]];
+    i && s < i ? r -= s : r += s;
+  }
+  return r;
+}, f = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12,
+  thirteen: 13,
+  fourteen: 14,
+  fifteen: 15,
+  sixteen: 16,
+  seventeen: 17,
+  eighteen: 18,
+  nineteen: 19,
+  twenty: 20
+}, _ = (e) => {
+  const t = e.trim().toLowerCase();
+  return /^\d+$/.test(t) ? Number.parseInt(t, 10) : f[t] !== void 0 ? f[t] : w(t);
+}, N = (e, t, r) => Math.min(r, Math.max(t, e)), b = (e, t, r) => e + (t - e) * r, F = (e, t, r) => e === t ? 0 : (r - e) / (t - e), B = (e, t, r, n, s) => n + (e - t) * (s - n) / (r - t), E = (e, t, r, n, s) => N(B(e, t, r, n, s), Math.min(n, s), Math.max(n, s)), S = (e, t, r) => e === t ? r < e ? 0 : 1 : N((r - e) / (t - e), 0, 1), U = (e, t, r) => {
+  const n = S(e, t, r);
+  return n * n * (3 - 2 * n);
+}, p = [
+  "B",
+  "KB",
+  "MB",
+  "GB",
+  "TB"
+], W = (e) => {
+  if (!Number.isFinite(e) || e <= 0) return "0 B";
+  let t = e, r = 0;
+  for (; t >= 1024 && r < p.length - 1; )
+    t /= 1024, r += 1;
+  return r === 0 ? `${Math.round(t)} B` : `${t.toFixed(1)} ${p[r]}`;
+};
+export {
+  g as Mathjs,
+  D as addNumSym,
+  N as clamp,
+  E as fit,
+  W as formatBytes,
+  F as inverseLerp,
+  b as lerp,
+  S as linearstep,
+  x as mathjs,
+  T as parseChineseNumber,
+  _ as parseEnglishNumber,
+  w as parseRomanNumber,
+  C as perToNum,
+  L as range,
+  B as remap,
+  U as smoothstep,
+  $ as transformNumber
+};

package/dist/src/utils/obj.d.ts

@@ -28,9 +28,9 @@ export declare function querystring(data?: {}): string;
  */
 export declare const formatJson: (value: string | object, onError?: (error: Error) => void, indent?: number) => string;
 /**
- * @description: Return a new object without the properties whose values appear in `list` — typically used to drop empty strings and nulls
+ * @description: Return a new object without the listed keys — typically used to drop fields before sending an object on
  * @param {Object} obj source object
- * @param {Array} list values to remove
+ * @param {Array} list keys to remove
  * @return {Object}
  */
 export declare const filterObj: (obj: Record<string, unknown>, list: Array<string>) => Record<string, unknown>;

package/dist/src/utils/obj.js

@@ -0,0 +1,140 @@
+import { once as O } from "./memoize.js";
+import { noop as g } from "./noop.js";
+function m(t = {}) {
+  if (typeof t != "object") throw new TypeError("param must be object");
+  return Object.entries(t).reduce((r, [e, n]) => (n === void 0 || n == null || r.append(decodeURIComponent(e), decodeURIComponent(n)), r), new URLSearchParams()).toString();
+}
+var E = (t, r = g, e = 4) => {
+  try {
+    const n = typeof t == "string" ? JSON.parse(t.replace(/'/g, '"')) : t;
+    return JSON.stringify(n, null, e) ?? "";
+  } catch (n) {
+    return r(n), "";
+  }
+}, S = (t, r) => {
+  const e = {};
+  return Object.keys(t).forEach((n) => {
+    r.includes(n) || (e[n] = t[n]);
+  }), e;
+}, a = (t, r) => {
+  if (t && r) for (const e in r) t[e] = r[e];
+  return t;
+};
+function x(t, r, e, n) {
+  if (typeof t > "u") return g;
+  if (!(r in t) && !n) return g;
+  const o = r in t, i = t[r], c = e(i);
+  if (typeof c != "function") return g;
+  t[r] = c;
+  let f = !1;
+  return () => {
+    f || (f = !0, t[r] === c && (o ? t[r] = i : delete t[r]));
+  };
+}
+var d = (t, r) => {
+  const e = Object.getOwnPropertyDescriptors(r);
+  for (const n of Object.keys(e)) {
+    const o = e[n];
+    if (o.get) {
+      const i = o.get;
+      Object.defineProperty(t, n, {
+        configurable: !1,
+        enumerable: !0,
+        get: O(i)
+      });
+    } else if (typeof o.value == "object") Object.defineProperty(t, n, {
+      configurable: !1,
+      enumerable: !0,
+      writable: !1,
+      value: d({}, o.value)
+    });
+    else throw new Error("Exposed values must be either a getter or an nested object");
+  }
+  return Object.freeze(t);
+};
+function j(t) {
+  return Object.prototype.toString.call(t);
+}
+function y(t, r, e = /* @__PURE__ */ new Map()) {
+  if (t === r) return !0;
+  if (t == null || r == null) return t === r;
+  if (t !== t && r !== r) return !0;
+  const n = typeof t;
+  if (n !== typeof r) return !1;
+  if (n !== "object") return t === r;
+  const o = j(t);
+  if (o !== j(r)) return !1;
+  if (e.has(t)) return e.get(t) === r;
+  if (e.set(t, r), o === "[object Array]") {
+    if (t.length !== r.length) return !1;
+    for (let f = 0; f < t.length; f++) if (!y(t[f], r[f], e)) return !1;
+    return !0;
+  }
+  if (o === "[object Date]") return +t == +r;
+  if (o === "[object RegExp]") return t.toString() === r.toString();
+  if (o === "[object Map]") {
+    if (t.size !== r.size) return !1;
+    let f = !0;
+    return t.forEach((b, p) => {
+      f && (!r.has(p) || !y(b, r.get(p), e)) && (f = !1);
+    }), f;
+  }
+  if (o === "[object Set]") {
+    if (t.size !== r.size) return !1;
+    const f = Array.from(t), b = Array.from(r);
+    return f.every((p) => b.some((u) => y(p, u, e)));
+  }
+  const i = Object.keys(t), c = Object.keys(r);
+  if (i.length !== c.length) return !1;
+  for (const f of i) if (!Object.prototype.hasOwnProperty.call(r, f) || !y(t[f], r[f], e)) return !1;
+  return !0;
+}
+var s = (t, r = /* @__PURE__ */ new WeakMap()) => {
+  if (t === null || typeof t != "object") return t;
+  if (r.has(t)) return r.get(t);
+  if (t instanceof Date) return new Date(t.getTime());
+  if (t instanceof RegExp) return new RegExp(t.source, t.flags);
+  if (Array.isArray(t)) {
+    const e = [];
+    r.set(t, e);
+    for (let n = 0; n < t.length; n++) e[n] = s(t[n], r);
+    return e;
+  }
+  if (t instanceof Map) {
+    const e = /* @__PURE__ */ new Map();
+    return r.set(t, e), t.forEach((n, o) => {
+      e.set(typeof o == "object" && o !== null ? s(o, r) : o, s(n, r));
+    }), e;
+  }
+  if (t instanceof Set) {
+    const e = /* @__PURE__ */ new Set();
+    return r.set(t, e), t.forEach((n) => {
+      e.add(s(n, r));
+    }), e;
+  }
+  if (typeof t == "object" && t.constructor === Object) {
+    const e = {};
+    return r.set(t, e), [...Object.getOwnPropertyNames(t), ...Object.getOwnPropertySymbols(t)].forEach((n) => {
+      e[n] = s(t[n], r);
+    }), e;
+  }
+  try {
+    const e = Object.getPrototypeOf(t).constructor, n = new e();
+    r.set(t, n);
+    for (const o in t) Object.prototype.hasOwnProperty.call(t, o) && (n[o] = s(t[o], r));
+    return n;
+  } catch {
+    return console.warn(`Unable to deeply clone object of type ${Object.prototype.toString.call(t)}. Fallback to shallow copy.`), { ...t };
+  }
+};
+export {
+  s as cloneDeep,
+  S as filterObj,
+  E as formatJson,
+  j as getTag,
+  y as isEqual,
+  a as merge,
+  d as mergeExports,
+  m as querystring,
+  x as replaceOld
+};

package/dist/src/utils/paginate.js

@@ -0,0 +1,93 @@
+var E = (() => {
+  const a = /* @__PURE__ */ new Uint8Array(128), c = `abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-.,!?;:'"()[]{}`;
+  for (let h = 0; h < 78; h++) a[c.charCodeAt(h)] = 1;
+  return a;
+})(), g = (a) => a < 128 && E[a] === 1, v = {
+  pages: [],
+  charsPerLine: 0,
+  linesPerPage: 0,
+  charsPerPage: 0
+}, L = (a, c, h, x = {}) => {
+  const l = a.replace(/(?:\r\n|\r|\n)+/g, `
+`) || "", i = l.length, w = x.minBox ?? 30, { charWidth: C, lineHeight: p } = h, R = h.narrowRatio ?? 0.5625;
+  if (c.width < w || c.height < w || C <= 0 || p <= 0) return {
+    ...v,
+    total: i
+  };
+  const d = Math.floor(c.width / C), f = Math.floor(c.height / p), u = d * f;
+  if (d <= 0 || f <= 0) return {
+    ...v,
+    total: i
+  };
+  const W = (r) => {
+    let e = r, n = r;
+    for (; e < i; ) {
+      const o = l.charCodeAt(e);
+      if (g(o)) e++;
+      else if (o === 32) {
+        n = e, e++;
+        break;
+      } else e++;
+    }
+    return n;
+  }, A = (r) => {
+    let e = r, n = r;
+    for (; e > 0; ) {
+      const o = l.charCodeAt(e - 1);
+      if (g(o))
+        n = e - 1, e--;
+      else {
+        if (o === 32) break;
+        e--;
+      }
+    }
+    return n;
+  }, P = [];
+  let t = 0;
+  for (; i > t; ) {
+    let r = 0, e = 0;
+    const n = t;
+    let o = u;
+    for (; r < f && e < u && t < i; ) {
+      const s = l.charCodeAt(t);
+      if (s === 10 || s === 13) {
+        r++, e = 0, t++, o--;
+        continue;
+      }
+      const S = g(s);
+      if (e >= d) {
+        if (S) {
+          const k = A(t);
+          if (W(t) - k > d) {
+            r++, e = 0;
+            continue;
+          }
+        }
+        r++, e = 0;
+        continue;
+      }
+      t++, e += S ? R : 1, o--;
+    }
+    if (t < i && g(l.charCodeAt(t))) {
+      const s = A(t);
+      W(t) - s > o && s > n && (t = s);
+    }
+    if (t === n) break;
+    P.push({
+      text: l.slice(n, t),
+      start: n,
+      end: t,
+      index: P.length
+    });
+  }
+  return {
+    pages: P,
+    total: i,
+    charsPerLine: d,
+    linesPerPage: f,
+    charsPerPage: u
+  };
+};
+export {
+  L as paginateText
+};

package/dist/src/utils/performance.js

@@ -0,0 +1,26 @@
+function B() {
+  if (typeof window < "u") {
+    const [c] = performance.getEntriesByType("navigation"), [d = {}, s = {}] = performance.getEntriesByType("paint"), { startTime: p } = d, { startTime: f } = s, { domainLookupEnd: m, domainLookupStart: u, connectEnd: t, connectStart: S, secureConnectionStart: E, loadEventStart: n, domInteractive: r, domContentLoadedEventEnd: o, duration: y, responseStart: i, requestStart: T, responseEnd: a, fetchStart: e, transferSize: g, encodedBodySize: v, redirectEnd: C, redirectStart: l, redirectCount: h } = c;
+    return {
+      dnsSearch: m - u,
+      tcpConnect: t - S,
+      sslConnect: t - E,
+      request: i - T,
+      response: a - i,
+      parseDomTree: r - a,
+      resource: n - o,
+      domReady: o - e,
+      interactive: r - e,
+      complete: n - e,
+      httpHead: g - v,
+      redirect: h,
+      redirectTime: C - l,
+      duration: y,
+      fp: p,
+      fcp: f
+    };
+  }
+}
+export {
+  B as getPerformance
+};