ranuts 0.4.1-alpha.1 → 0.5.0

package/dist/src/utils/storage.js

@@ -0,0 +1,53 @@
+var o = () => {
+  try {
+    return typeof localStorage > "u" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}, l = (r, e) => {
+  try {
+    o()?.setItem(r, e);
+  } catch {
+  }
+}, n = (r) => {
+  try {
+    return o()?.getItem(r) ?? "";
+  } catch {
+    return "";
+  }
+}, u = (r) => {
+  try {
+    o()?.removeItem(r);
+  } catch {
+  }
+}, m = (r = "") => {
+  const e = (t) => `${r}${t}`;
+  return {
+    keyOf: e,
+    get: (t, c) => {
+      const a = n(e(t));
+      if (!a) return c;
+      try {
+        return JSON.parse(a);
+      } catch {
+        return c;
+      }
+    },
+    set: (t, c) => {
+      let a;
+      try {
+        a = JSON.stringify(c);
+      } catch {
+        return !1;
+      }
+      return l(e(t), a), n(e(t)) === a;
+    },
+    remove: (t) => u(e(t))
+  };
+};
+export {
+  m as createStore,
+  n as localStorageGetItem,
+  u as localStorageRemoveItem,
+  l as localStorageSetItem
+};

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

@@ -107,12 +107,6 @@ export interface TransformText {
     content: string;
 }
 export declare const transformText: (content: string | ArrayBuffer) => TransformText | undefined;
-/**
- * MD5 hash function implementation
- * @param str The string to hash
- * @returns The MD5 hash as a hexadecimal string
- */
-export declare const md5: (str: string) => string;
 /**
  * @description: A short random-ish base-36 string.
  *

package/dist/src/utils/str.js

@@ -0,0 +1,395 @@
+import { detect as w } from "jschardet";
+var m = (r = "", e = "", t = "") => {
+  const n = {}, o = r.split(e);
+  return o.length > 0 && o.forEach((a) => {
+    const [h = "", s = ""] = a.split(t);
+    u(h) && (n[u(h)] = u(s));
+  }), n;
+}, E = (r = "") => {
+  if (r.length === 0) return "";
+  let e = "", t = 0;
+  for (const n of r)
+    if (!/\s/.test(n)) {
+      if (n === "<") {
+        t++;
+        continue;
+      }
+      if (n === ">" && t > 0) {
+        t--;
+        continue;
+      }
+      t === 0 && (e += n);
+    }
+  return e;
+}, A = (r) => window.toString.call(r) === "[object String]";
+function C(r = 8) {
+  const e = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678";
+  let n = "";
+  for (let o = 0; o < r; o++) n += e.charAt(Math.floor(Math.random() * 48));
+  return `${Date.now()}-${n}`;
+}
+var u = (r, e = {}) => {
+  const { urlencoded: t = !0 } = e, n = String.prototype.trim.call(r);
+  return t ? decodeURIComponent(n).replace(/"|'/g, "") : n.replace(/"|'/g, "");
+};
+function S(r, e) {
+  if (!r || !e) return [];
+  const t = [], n = new RegExp(e, "gi");
+  let o;
+  for (; (o = n.exec(r)) !== null; ) {
+    const s = o.index;
+    let c = s;
+    for (; c > 0; ) {
+      const i = r[c - 1];
+      if (i === "。" || i === "." || i === `
+` || i === "！" || i === "?" || i === "？") break;
+      c--;
+    }
+    let l = s + e.length;
+    for (; l < r.length; ) {
+      const i = r[l];
+      if (i === "。" || i === "." || i === `
+` || i === "！" || i === "?" || i === "？") {
+        l++;
+        break;
+      }
+      l++;
+    }
+    const f = r.slice(c, l).trim();
+    f && t.push({
+      sentence: f,
+      start: c,
+      end: l
+    });
+  }
+  const a = [], h = [];
+  t.sort((s, c) => c.sentence.length - s.sentence.length);
+  for (const s of t) h.some((c) => !(s.end <= c.start || s.start >= c.end)) || (a.push(s.sentence), h.push({
+    start: s.start,
+    end: s.end
+  }));
+  return [...new Set(a)];
+}
+var v = (r) => String(r), g = (r) => {
+  const e = Array.from(r).map((t) => String.fromCharCode(t)).join("");
+  return w(e).encoding || "utf-8";
+}, R = (r) => {
+  const e = r instanceof Uint8Array ? r : new Uint8Array(r);
+  return new TextDecoder(g(e)).decode(e);
+}, I = (r) => r.replace(/[！-～]/g, (e) => String.fromCharCode(e.charCodeAt(0) - 65248)).replace(/\u3000/g, " "), b = (r) => r.replace(/[!-~]/g, (e) => String.fromCharCode(e.charCodeAt(0) + 65248)).replace(/ /g, "　"), M = (r, e) => {
+  const { length: t, position: n = "end", ellipsis: o = "…" } = typeof e == "number" ? { length: e } : e;
+  if (!r) return r;
+  const a = Array.from(r), h = Array.from(o);
+  if (a.length <= t) return r;
+  if (t <= h.length) return h.slice(0, Math.max(0, t)).join("");
+  const s = t - h.length;
+  if (n === "start") return o + a.slice(a.length - s).join("");
+  if (n === "middle") {
+    const c = Math.ceil(s / 2);
+    return a.slice(0, c).join("") + o + a.slice(a.length - (s - c)).join("");
+  }
+  return a.slice(0, s).join("") + o;
+}, D = (r) => {
+  if (r instanceof ArrayBuffer) {
+    const e = new Uint8Array(r), t = String.fromCharCode.apply(null, e), n = w(t), o = n.encoding || "utf-8", a = new TextDecoder(o).decode(r);
+    if (n.encoding && a) return {
+      encoding: n.encoding,
+      content: a
+    };
+  }
+}, U = (r = 8) => Math.random().toString(36).substring(2, r + 2), d = class extends Error {
+  code;
+  constructor(r, e) {
+    super(r), this.code = e, this.name = "MessageCodecError";
+  }
+}, B = {
+  encode(r) {
+    try {
+      const e = JSON.stringify(r), t = new TextEncoder().encode(e);
+      let n = "";
+      const o = 32768;
+      for (let a = 0; a < t.length; a += o) n += String.fromCharCode.apply(null, Array.from(t.subarray(a, a + o)));
+      return btoa(n);
+    } catch {
+      return "";
+    }
+  },
+  decode(r) {
+    try {
+      const e = atob(r), t = new Uint8Array(e.length);
+      for (let o = 0; o < e.length; o++) t[o] = e.charCodeAt(o);
+      const n = new TextDecoder().decode(t);
+      return JSON.parse(n);
+    } catch {
+      return null;
+    }
+  },
+  async encodeFile(r) {
+    try {
+      const e = await r.arrayBuffer();
+      return this.encode({
+        type: "File",
+        name: r.name,
+        mimeType: r.type,
+        size: r.size,
+        lastModified: r.lastModified,
+        content: new Uint8Array(e)
+      });
+    } catch (e) {
+      throw new d(`Failed to encode file: ${e instanceof Error ? e.message : "Unknown error"}`, "FILE_ENCODE_ERROR");
+    }
+  },
+  decodeFile(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "File") throw new d(`Expected File type but got ${e.type}`, "INVALID_FILE_TYPE");
+      const t = e, n = t.content instanceof Uint8Array ? t.content.buffer.slice(0) : t.content;
+      return new File([n], t.name, {
+        type: t.mimeType,
+        lastModified: t.lastModified
+      });
+    } catch (e) {
+      throw e instanceof d ? e : new d(`Failed to decode file: ${e instanceof Error ? e.message : "Unknown error"}`, "FILE_DECODE_ERROR");
+    }
+  },
+  async encodeBlob(r) {
+    try {
+      const e = await r.arrayBuffer();
+      return this.encode({
+        type: "Blob",
+        mimeType: r.type,
+        size: r.size,
+        content: new Uint8Array(e)
+      });
+    } catch (e) {
+      throw new d(`Failed to encode blob: ${e instanceof Error ? e.message : "Unknown error"}`, "BLOB_ENCODE_ERROR");
+    }
+  },
+  decodeBlob(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "Blob") throw new d(`Expected Blob type but got ${e.type}`, "INVALID_BLOB_TYPE");
+      const t = e, n = t.content instanceof Uint8Array ? t.content.buffer.slice(0) : t.content;
+      return new Blob([n], { type: t.mimeType });
+    } catch (e) {
+      throw e instanceof d ? e : new d(`Failed to decode blob: ${e instanceof Error ? e.message : "Unknown error"}`, "BLOB_DECODE_ERROR");
+    }
+  },
+  encodeDate(r) {
+    try {
+      return this.encode({
+        type: "Date",
+        value: r.toISOString()
+      });
+    } catch (e) {
+      throw e;
+    }
+  },
+  decodeDate(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "Date") throw new Error("Invalid encoded Date data");
+      return new Date(e.value);
+    } catch (e) {
+      throw e;
+    }
+  },
+  encodeRegExp(r) {
+    try {
+      return this.encode({
+        type: "RegExp",
+        source: r.source,
+        flags: r.flags
+      });
+    } catch (e) {
+      throw e;
+    }
+  },
+  decodeRegExp(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "RegExp") throw new Error("Invalid encoded RegExp data");
+      return new RegExp(e.source, e.flags);
+    } catch (e) {
+      throw e;
+    }
+  },
+  encodeMap(r) {
+    try {
+      return this.encode({
+        type: "Map",
+        value: Array.from(r.entries())
+      });
+    } catch (e) {
+      throw e;
+    }
+  },
+  decodeMap(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "Map") throw new Error("Invalid encoded Map data");
+      return new Map(e.value);
+    } catch (e) {
+      throw e;
+    }
+  },
+  encodeSet(r) {
+    try {
+      return this.encode({
+        type: "Set",
+        value: Array.from(r)
+      });
+    } catch (e) {
+      throw e;
+    }
+  },
+  decodeSet(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "Set") throw new Error("Invalid encoded Set data");
+      return new Set(e.value);
+    } catch (e) {
+      throw e;
+    }
+  },
+  encodeError(r) {
+    try {
+      return this.encode({
+        type: "Error",
+        name: r.name,
+        message: r.message,
+        stack: r.stack
+      });
+    } catch (e) {
+      throw e;
+    }
+  },
+  decodeError(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "Error") throw new Error("Invalid encoded Error data");
+      const t = new Error(e.message);
+      return t.name = e.name, t.stack = e.stack, t;
+    } catch (e) {
+      throw e;
+    }
+  },
+  encodeArrayBuffer(r) {
+    try {
+      return this.encode({
+        type: "ArrayBuffer",
+        value: Array.from(new Uint8Array(r))
+      });
+    } catch (e) {
+      throw e;
+    }
+  },
+  decodeArrayBuffer(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "ArrayBuffer") throw new Error("Invalid encoded ArrayBuffer data");
+      return new Uint8Array(e.value).buffer;
+    } catch (e) {
+      throw e;
+    }
+  },
+  encodeTypedArray(r) {
+    try {
+      return this.encode({
+        type: "TypedArray",
+        constructor: r.constructor.name,
+        value: Array.from(new Uint8Array(r.buffer, r.byteOffset, r.byteLength))
+      });
+    } catch {
+      return "";
+    }
+  },
+  decodeTypedArray(r) {
+    try {
+      const e = this.decode(r);
+      if (e.type !== "TypedArray") throw new Error("Invalid encoded TypedArray data");
+      const t = window[e.constructor];
+      return new t(e.value);
+    } catch (e) {
+      throw e;
+    }
+  },
+  async encodeFileChunked(r, e = 16384) {
+    try {
+      if (e <= 0) throw new d("Chunk size must be greater than 0", "INVALID_CHUNK_SIZE");
+      const t = Math.ceil(r.size / e), n = [];
+      for (let o = 0; o < t; o++) {
+        const a = o * e, h = Math.min(a + e, r.size), s = await r.slice(a, h).arrayBuffer(), c = String.fromCharCode.apply(null, Array.from(new Uint8Array(s)));
+        n.push({
+          name: r.name,
+          type: r.type,
+          size: r.size,
+          lastModified: r.lastModified,
+          totalChunks: t,
+          chunkIndex: o,
+          data: c
+        });
+      }
+      return n;
+    } catch (t) {
+      throw t instanceof d ? t : new d(`Failed to encode file chunks: ${t instanceof Error ? t.message : "Unknown error"}`, "FILE_CHUNK_ENCODE_ERROR");
+    }
+  },
+  async decodeFileChunked(r) {
+    try {
+      if (!r.length) throw new d("No chunks provided", "NO_CHUNKS");
+      const { type: e, lastModified: t, totalChunks: n } = r[0];
+      if (r.length !== n) throw new d(`Missing chunks. Expected ${n}, got ${r.length}`, "INCOMPLETE_CHUNKS");
+      r.sort((c, l) => c.chunkIndex - l.chunkIndex);
+      for (let c = 0; c < r.length; c++) if (r[c].chunkIndex !== c) throw new d(`Invalid chunk index at position ${c}`, "INVALID_CHUNK_ORDER");
+      const o = await Promise.all(r.map(async (c) => {
+        const l = c.data, f = new Uint8Array(l.length);
+        for (let i = 0; i < l.length; i++) f[i] = l.charCodeAt(i);
+        return f;
+      })), a = r.reduce((c, l) => c + l.data.length, 0), h = new Uint8Array(a);
+      let s = 0;
+      for (const c of o)
+        h.set(c, s), s += c.length;
+      return new File([h.buffer.slice(0)], r[0].name, {
+        type: e,
+        lastModified: t
+      });
+    } catch (e) {
+      throw e instanceof d ? e : new d(`Failed to decode file chunks: ${e instanceof Error ? e.message : "Unknown error"}`, "FILE_CHUNK_DECODE_ERROR");
+    }
+  }
+}, _ = (r, e, t = "…[truncated]") => r.length > e ? r.slice(0, e) + t : r, x = (r, e = "") => {
+  const t = Math.max(0, ...Array.from(r.matchAll(/`+/g), (o) => o[0].length)), n = "`".repeat(Math.max(3, t + 1));
+  return `${n}${e}
+${r}
+${n}`;
+}, y = (r) => {
+  let e = 0, t = r.length;
+  for (; e < t && r[e] === "-"; ) e++;
+  for (; t > e && r[t - 1] === "-"; ) t--;
+  return r.slice(e, t);
+}, F = (r, e = 60) => y(y(r.toLowerCase().replace(/[^a-z0-9]+/g, "-")).slice(0, e)), O = (r) => {
+  const e = String(r), t = /^[=+\-@]/.test(e) ? `'${e}` : e;
+  return /[",\n\r]/.test(t) ? `"${t.replace(/"/g, '""')}"` : t;
+};
+export {
+  B as MessageCodec,
+  R as arrayBufferToString,
+  g as checkEncoding,
+  E as clearBr,
+  u as clearStr,
+  O as csvEscape,
+  x as fenceCode,
+  S as getMatchingSentences,
+  U as getRandomString,
+  A as isString,
+  C as randomString,
+  F as slugify,
+  m as strParse,
+  b as toFullWidth,
+  I as toHalfWidth,
+  v as toString,
+  D as transformText,
+  M as truncate,
+  _ as truncateWithMarker
+};

package/dist/src/utils/style.js

@@ -0,0 +1,29 @@
+var d = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map(), y = "data-adopted-style", S = "data-adopted-sheet", a = (n, e, r) => {
+  if (typeof CSSStyleSheet > "u") return !1;
+  try {
+    if (!r.has(e)) {
+      const l = new CSSStyleSheet();
+      l.replaceSync(e), r.set(e, l);
+    }
+    const t = r.get(e);
+    return n.adoptedStyleSheets.includes(t) || (n.adoptedStyleSheets = [...n.adoptedStyleSheets, t]), !0;
+  } catch {
+    return !1;
+  }
+}, f = (n, e, r = y) => {
+  if (!(typeof document > "u") && e && !a(n, e, d) && !n.querySelector(`style[${r}]`)) {
+    const t = document.createElement("style");
+    t.setAttribute(r, ""), t.textContent = e, n.appendChild(t);
+  }
+}, i = (n, e, r = S) => {
+  if (!(typeof document > "u") && e && !a(n, e, u) && !Array.from(n.querySelectorAll(`style[${r}]`)).some((t) => t.textContent === e)) {
+    const t = document.createElement("style");
+    t.setAttribute(r, ""), t.textContent = e, n.appendChild(t);
+  }
+};
+export {
+  S as ADOPTED_SHEET_MARKER,
+  y as ADOPTED_STYLE_MARKER,
+  i as adoptSheetText,
+  f as adoptStyles
+};

package/dist/src/utils/subscribe.js

@@ -0,0 +1,58 @@
+var i = "NEW_LISTENER", n = class {
+  _events = /* @__PURE__ */ new Map();
+  tap = (l, c) => {
+    this._events.get(l) && l !== /* @__PURE__ */ Symbol.for("NEW_LISTENER") && this.call(Symbol.for(i), l);
+    const a = this._events.get(l) || /* @__PURE__ */ new Set();
+    return typeof c == "function" ? a.add({
+      name: l,
+      callback: c
+    }) : a.add(c), this._events.set(l, a), this;
+  };
+  call = (l, ...c) => ((this._events.get(l) || /* @__PURE__ */ new Set()).forEach((a) => {
+    const { callback: s } = a;
+    s(...c);
+  }), this);
+  callSync = async (l, ...c) => {
+    const a = this._events.get(l) || /* @__PURE__ */ new Set();
+    for (const s of a) {
+      const { callback: t } = s;
+      await t(...c);
+    }
+    return this;
+  };
+  once = (l, c) => {
+    let a;
+    if (typeof c == "function") a = {
+      name: l,
+      callback: (...s) => {
+        c(...s), this.off(l, a);
+      },
+      initialCallback: c
+    };
+    else {
+      const { callback: s } = c;
+      a = {
+        name: l,
+        callback: (...t) => {
+          s(...t), this.off(l, a);
+        },
+        initialCallback: s
+      };
+    }
+    return this.tap(l, a), this;
+  };
+  off = (l, c) => {
+    const a = [...this._events.get(l) || /* @__PURE__ */ new Set()].filter((s) => {
+      if (typeof c == "function") return s.callback !== c && s.initialCallback !== c;
+      {
+        const { callback: t } = c;
+        return s.callback !== t && s.initialCallback !== t;
+      }
+    });
+    return this._events.set(l, new Set(a)), this;
+  };
+};
+export {
+  i as NEW_LISTENER,
+  n as SyncHook
+};

package/dist/src/utils/throttle.js

@@ -0,0 +1,17 @@
+function c(r, a = 300) {
+  let u = 0, l = null, n, t = null;
+  const s = () => {
+    if (l = null, !t) return;
+    const o = t, e = n;
+    t = null, n = void 0, u = Date.now(), r.apply(e, o);
+  }, i = function(...o) {
+    const e = a - (Date.now() - u);
+    n = this, t = o, e <= 0 ? (l !== null && (clearTimeout(l), l = null), s()) : l === null && (l = setTimeout(s, e));
+  };
+  return i.cancel = () => {
+    l !== null && clearTimeout(l), l = null, t = null, n = void 0;
+  }, i.pending = () => l !== null, i;
+}
+export {
+  c as throttle
+};

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

@@ -29,18 +29,6 @@ export type DateInput = number | string | Date;
  * ```
  */
 export declare const formatDate: (value?: DateInput, pattern?: string) => string;
-/**
- * @description: Turn a timestamp into a `Date` carrying a `format` method.
- * @deprecated Use [`formatDate`](#formatdate). This returns a `Date` with an extra method
- * bolted onto the instance, which does not survive serialization, breaks `instanceof`-based
- * type narrowing on the extra property, and is untypeable beyond `Function`. Its `format`
- * now delegates to `formatDate`, so the token handling is fixed here too.
- * @param {number | string} timestamp omit for the current time
- * @return {Date & { format?: Function }}
- */
-export declare function timestampToTime(timestamp?: number | string): Date & {
-    format?: Function;
-};
 /**
  * @description: Format an elapsed number of **seconds** as a colon-separated clock duration,
  * the shape media players use for a playhead: `mm:ss`, widening to `hh:mm:ss` past an hour.
@@ -61,15 +49,6 @@ export declare function timestampToTime(timestamp?: number | string): Date & {
  * ```
  */
 export declare const formatDuration: (seconds: number) => string;
-/**
- * @description: Format a number of seconds as a colon-separated duration
- * @deprecated Renamed to [`formatDuration`](#formatduration) — `timeFormat` said nothing about
- * *which* of the three time formats it was, and read backwards from its `formatDate` sibling.
- * This alias stays for compatibility and behaves identically.
- * @param {number} time
- * @return {string}
- */
-export declare const timeFormat: (time: number) => string;
 /**
  * @description: Parse a WebVTT/SRT-style timestamp — `HH:MM:SS.mmm` or `MM:SS.mmm` (the hour
  * component is optional) — into seconds. The inverse of [`formatDuration`](#formatduration),

package/dist/src/utils/time.js

@@ -0,0 +1,97 @@
+var o = (e, r = 2) => String(e).padStart(r, "0"), l = (e) => e == null ? /* @__PURE__ */ new Date() : new Date(e), T = /YYYY|YY|MM|M|DD|D|HH|H|hh|h|mm|m|ss|s|SSS|A|a|\[([^[\]]*)]/g, w = (e, r = "YYYY-MM-DD HH:mm:ss") => {
+  const t = l(e);
+  if (Number.isNaN(t.getTime())) return "Invalid Date";
+  const n = t.getHours(), a = n % 12 || 12, m = {
+    YYYY: String(t.getFullYear()),
+    YY: o(t.getFullYear() % 100),
+    MM: o(t.getMonth() + 1),
+    M: String(t.getMonth() + 1),
+    DD: o(t.getDate()),
+    D: String(t.getDate()),
+    HH: o(n),
+    H: String(n),
+    hh: o(a),
+    h: String(a),
+    mm: o(t.getMinutes()),
+    m: String(t.getMinutes()),
+    ss: o(t.getSeconds()),
+    s: String(t.getSeconds()),
+    SSS: o(t.getMilliseconds(), 3),
+    A: n < 12 ? "AM" : "PM",
+    a: n < 12 ? "am" : "pm"
+  };
+  return r.replace(T, (d, u) => u !== void 0 ? u : m[d]);
+}, y = (e) => {
+  if (!Number.isFinite(e)) return "";
+  const r = Math.max(0, Math.trunc(e)), t = Math.trunc(r / 3600), n = Math.trunc(r % 3600 / 60), a = o(r % 60);
+  return t === 0 ? `${o(n)}:${a}` : `${o(t)}:${o(n)}:${a}`;
+}, b = /(?:(\d{2,}):)?(\d{2}):(\d{2})\.(\d{3})/, Y = (e) => {
+  const r = e.trim().match(b);
+  if (!r) return;
+  const [, t, n, a, m] = r;
+  return (t ? Number(t) * 3600 : 0) + Number(n) * 60 + Number(a) + Number(m) / 1e3;
+}, H = (e) => {
+  const [r, t] = e.split("-->");
+  if (!r || !t) return;
+  const n = Y(r), a = Y(t.trim().split(/\s+/)[0] ?? "");
+  if (!(n === void 0 || a === void 0))
+    return {
+      start: n,
+      end: a
+    };
+}, c = [
+  ["year", 315576e5],
+  ["month", 26298e5],
+  ["week", 6048e5],
+  ["day", 864e5],
+  ["hour", 36e5],
+  ["minute", 6e4],
+  ["second", 1e3]
+], D = {
+  year: "y",
+  quarter: "q",
+  month: "mo",
+  week: "w",
+  day: "d",
+  hour: "h",
+  minute: "m",
+  second: "s"
+}, N = /* @__PURE__ */ new Map(), $ = (e, r, t) => {
+  if (typeof Intl > "u" || typeof Intl.RelativeTimeFormat != "function") return;
+  const n = `${String(e)}|${r}|${t}`;
+  let a = N.get(n);
+  return a || (a = new Intl.RelativeTimeFormat(e, {
+    style: r,
+    numeric: t
+  }), N.set(n, a)), a;
+}, I = (e, r = {}) => {
+  const { now: t, locale: n, style: a = "long", numeric: m = "auto" } = r, d = l(e).getTime(), u = l(t).getTime();
+  if (Number.isNaN(d) || Number.isNaN(u)) return "";
+  const v = d - u, M = Math.abs(v);
+  let s = c.findIndex(([, h]) => M >= h);
+  s === -1 && (s = c.length - 1);
+  const p = v < 0 ? -1 : 1;
+  let [g, f] = c[s], i = p * Math.round(M / f);
+  if (s > 0 && Math.abs(i) * f >= c[s - 1][1] && ([g, f] = c[s - 1], i = p * Math.round(M / f)), a === "compact") return `${Math.abs(i)}${D[g] ?? ""}`;
+  const S = $(n, a, m);
+  if (!S) {
+    const h = D[g] ?? "";
+    return i < 0 ? `${Math.abs(i)}${h} ago` : `in ${i}${h}`;
+  }
+  return S.format(i, g);
+}, F = () => {
+  if (typeof document < "u") return performance.now();
+  if (typeof process < "u") {
+    const [e, r] = process.hrtime();
+    return e * 1e3 + r / 1e6;
+  }
+  return Date.now();
+};
+export {
+  w as formatDate,
+  y as formatDuration,
+  I as formatRelative,
+  H as parseVttCueTiming,
+  Y as parseVttTimestamp,
+  F as performanceTime
+};