ranuts 0.4.1-alpha.2 → 0.5.0

package/dist/src/utils/prefetch.js

@@ -0,0 +1,69 @@
+var o = () => typeof window < "u", f = (e, r = {}) => {
+  const { timeout: t = 8e3, fallbackDelay: a = 2500 } = r;
+  if (!o()) return () => {
+  };
+  const c = window.requestIdleCallback;
+  if (c) {
+    const s = c(e, { timeout: t });
+    return () => window.cancelIdleCallback?.(s);
+  }
+  const i = setTimeout(e, a);
+  return () => clearTimeout(i);
+}, l = (e = {}) => {
+  const { optOutKey: r, slowTypes: t = ["slow-2g", "2g"] } = e;
+  if (!o()) return !1;
+  if (r) try {
+    if (localStorage.getItem(r)) return !1;
+  } catch {
+  }
+  const a = navigator.connection;
+  return !(a?.saveData || a?.effectiveType && t.includes(a.effectiveType));
+}, d = () => typeof caches < "u", u = async (e) => {
+  if (!d()) return !1;
+  try {
+    return !!await caches.match(e);
+  } catch {
+    return !1;
+  }
+}, n = /* @__PURE__ */ new Map(), h = (e) => {
+  const r = n.get(e);
+  if (r) return r;
+  const t = (async () => {
+    try {
+      if (await u(e)) return;
+      const a = (await fetch(e, { cache: "force-cache" })).body?.getReader();
+      if (!a) return;
+      try {
+        for (; !(await a.read()).done; ) ;
+      } finally {
+        a.releaseLock();
+      }
+    } catch {
+    }
+  })().finally(() => n.delete(e));
+  return n.set(e, t), t;
+}, v = (e, r) => {
+  try {
+    const t = typeof navigator < "u" && "serviceWorker" in navigator ? navigator.serviceWorker.controller : null;
+    return t ? (t.postMessage({
+      type: r,
+      urls: e
+    }), !0) : !1;
+  } catch {
+    return !1;
+  }
+}, w = async (e, r = {}) => {
+  if (e.length !== 0 && !(r.serviceWorkerMessage && v(e, r.serviceWorkerMessage)))
+    for (const t of e) await h(t);
+}, y = (e, r = {}) => l(r) ? f(() => {
+  w(e, r);
+}, r) : () => {
+};
+export {
+  u as isUrlCached,
+  l as networkAllowsDownload,
+  h as prefetchUrl,
+  w as prefetchUrls,
+  y as prefetchWhenIdle,
+  f as whenIdle
+};

package/dist/src/utils/queue.js

@@ -0,0 +1,46 @@
+var i = class {
+  running = 0;
+  executed = 0;
+  simultaneous;
+  queue = [];
+  idleWaiters = [];
+  constructor({ simultaneous: e = 1 } = {}) {
+    this.simultaneous = Math.max(1, e);
+  }
+  get pending() {
+    return this.queue.length;
+  }
+  get idle() {
+    return this.queue.length === 0 && this.running === 0;
+  }
+  add = (e) => typeof e != "function" ? Promise.reject(/* @__PURE__ */ new TypeError("QuestQueue.add expects a function")) : new Promise((t, s) => {
+    this.queue.push({
+      task: e,
+      resolve: t,
+      reject: s
+    }), this.next();
+  });
+  allSettled = (e) => Promise.allSettled(e.map((t) => this.add(t)));
+  onIdle = () => this.idle ? Promise.resolve() : new Promise((e) => this.idleWaiters.push(e));
+  clear = () => {
+    const e = this.queue.splice(0, this.queue.length);
+    for (const t of e) t.reject(/* @__PURE__ */ new Error("QuestQueue cleared"));
+    this.settleIdle();
+  };
+  next = () => {
+    for (; this.running < this.simultaneous && this.queue.length > 0; ) {
+      const e = this.queue.shift();
+      this.running++, Promise.resolve().then(e.task).then(e.resolve, e.reject).finally(() => {
+        this.running--, this.executed++, this.settleIdle(), this.next();
+      });
+    }
+  };
+  settleIdle = () => {
+    if (!this.idle) return;
+    const e = this.idleWaiters.splice(0, this.idleWaiters.length);
+    for (const t of e) t();
+  };
+};
+export {
+  i as QuestQueue
+};

package/dist/src/utils/report.js

@@ -0,0 +1,44 @@
+import { randomString as i } from "./str.js";
+import { getCookie as a, getWindow as s } from "./bom.js";
+import { querystring as f } from "./obj.js";
+var o = {}, l = (e) => {
+  typeof e == "string" ? o.url = e : Object.assign(o, e);
+}, u = () => o.url ?? "", d = ({ url: e = "", type: t = "application/json; charset=UTF-8", payload: r = {} }) => {
+  if (typeof navigator > "u" || !navigator.sendBeacon || !e) return !1;
+  const n = new Blob([JSON.stringify(r)], { type: t });
+  return navigator.sendBeacon(e, n);
+}, g = ({ url: e = "", payload: t = {} }) => {
+  if (typeof document > "u" || !e) return !1;
+  const r = new Image();
+  return r.width = 1, r.height = 1, r.src = `${e}?${f(t)}`, !0;
+}, w = ({ url: e, type: t = "application/json; charset=UTF-8", payload: r = {} }) => {
+  const n = e || u();
+  return n ? d({
+    url: n,
+    type: t,
+    payload: r
+  }) || g({
+    url: n,
+    payload: r
+  }) : !1;
+};
+function h(e = {}) {
+  if (typeof window > "u") return {};
+  const { width: t, height: r } = s();
+  return {
+    id: i(),
+    path: window.location.href,
+    time: Date.now(),
+    referrer: document.referrer,
+    ratio: `${t}x${r}`,
+    userAgent: window.navigator.userAgent,
+    ...o.userIdCookie ? { userId: a(o.userIdCookie) } : {},
+    ...e
+  };
+}
+export {
+  h as createData,
+  u as getReportUrl,
+  w as report,
+  l as setReportUrl
+};

package/dist/src/utils/request.js

@@ -0,0 +1,35 @@
+import { noop as o } from "./noop.js";
+import { replaceOld as c } from "./obj.js";
+var y = (s = {}) => {
+  if (typeof window > "u") return o;
+  const { requestHook: r = o, responseHook: d = o, errorHook: u = o } = s;
+  return c(window, "fetch", (i) => {
+    if (typeof i != "function") return;
+    const f = i;
+    return (n, t) => (r(n, t), f.apply(window, [n, t]).then((e) => (d(n, t, e), e)).catch((e) => {
+      throw u(n, e), e;
+    }));
+  });
+}, H = (s = {}) => {
+  if (typeof window > "u" || typeof XMLHttpRequest > "u") return o;
+  const r = XMLHttpRequest.prototype, { requestHook: d = o, responseHook: u = o, errorHook: i = o } = s, f = c(r, "open", (t) => {
+    if (typeof t != "function") return;
+    const e = t;
+    return function(...p) {
+      d(p), e.apply(this, p);
+    };
+  }), n = c(r, "send", (t) => {
+    if (typeof t != "function") return;
+    const e = t;
+    return function(...p) {
+      this.addEventListener("loadend", () => u(this), { once: !0 }), this.addEventListener("error", () => i(this), { once: !0 }), e.apply(this, p);
+    };
+  });
+  return () => {
+    n(), f();
+  };
+};
+export {
+  y as handleFetchHook,
+  H as handleXhrHook
+};

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

@@ -12,7 +12,7 @@ export interface LoadScriptOptions {
  * and **guarantees the same script is evaluated only once** — injecting a third-party SDK
  * twice usually means its initialisation side effects ran twice.
  *
- * The de-duplication key is the md5 of `type + content`, so a URL and an identically named inline script cannot be confused.
+ * The key includes the type and exact content, so distinct sources and URL/inline scripts stay separate.
  *
  * @param {LoadScriptOptions} options
  * @return {Promise<{ success: boolean }>} rejects with `{ success: false, error }` on failure

package/dist/src/utils/script.js

@@ -0,0 +1,46 @@
+var d = /* @__PURE__ */ new Set(), p = ({ type: t, content: o }) => new Promise((r, a) => {
+  const e = `${t}:${o}`;
+  if (d.has(e)) {
+    r({ success: !0 });
+    return;
+  }
+  const n = document.createElement("script");
+  if (n.onload = function() {
+    d.add(e), r({ success: !0 });
+  }, n.onerror = function(s) {
+    a({
+      success: !1,
+      error: s
+    });
+  }, t === "content") {
+    n.textContent = o, document.body.append(n), d.add(e), r({ success: !0 });
+    return;
+  }
+  n.src = o, document.body.append(n);
+}), m = (t, o, r) => {
+  t = Array.isArray(t) ? t : [t];
+  const a = t.map((e) => {
+    const n = e.toLowerCase().endsWith(".css");
+    let s;
+    if (n) {
+      const c = document.createElement("link");
+      c.type = "text/css", c.rel = "stylesheet", c.href = e, s = c;
+    } else
+      s = document.createElement("script"), s.type = "text/javascript", s.src = e;
+    const i = document.getElementsByTagName("body")[0];
+    return (o || i).appendChild(s), new Promise((c) => {
+      s.onload = () => {
+        c();
+      };
+    });
+  });
+  return new Promise((e) => {
+    Promise.all(a).then(() => {
+      r && r(), e();
+    });
+  });
+};
+export {
+  p as loadScript,
+  m as scriptOnLoad
+};

package/dist/src/utils/scroll.js

@@ -0,0 +1,62 @@
+var b = 24;
+function H(r) {
+  return Math.max(0, r.scrollHeight - r.clientHeight);
+}
+function h(r, e) {
+  return r.getBoundingClientRect().top - e.getBoundingClientRect().top;
+}
+function m(r) {
+  const { scrollport: e, observe: u = [], threshold: g = b, onPinnedChange: T } = r;
+  let l = !0, n = e.scrollTop, t = null, f = !1;
+  const p = (o) => {
+    o !== l && (l = o, T?.(o));
+  }, s = (o) => {
+    e.scrollTop = o, n = e.scrollTop;
+  }, a = () => {
+    t = null, s(e.scrollHeight), p(!0);
+  }, d = () => {
+    const o = H(e);
+    if (!(Math.abs(e.scrollTop - Math.min(n, o)) > 0.5)) {
+      l ? a() : n = e.scrollTop;
+      return;
+    }
+    n = e.scrollTop, p(o - e.scrollTop <= g);
+  };
+  e.addEventListener("scroll", d, { passive: !0 });
+  let c = null;
+  if (u.length > 0 && typeof ResizeObserver < "u") {
+    c = new ResizeObserver(() => {
+      l && !f && s(e.scrollHeight);
+    });
+    for (const o of u) c.observe(o);
+  }
+  return {
+    get pinned() {
+      return l;
+    },
+    toBottom: a,
+    follow() {
+      l && s(e.scrollHeight);
+    },
+    captureAnchor(o) {
+      t = {
+        row: o,
+        top: h(o, e)
+      };
+    },
+    restoreAnchor(o) {
+      if (t === null) return !1;
+      const i = o === void 0 ? t.row : o(), { top: v } = t;
+      return t = null, i === null || !e.contains(i) ? !1 : (s(e.scrollTop + h(i, e) - v), !0);
+    },
+    releaseAnchor() {
+      t = null;
+    },
+    destroy() {
+      f = !0, e.removeEventListener("scroll", d), c?.disconnect();
+    }
+  };
+}
+export {
+  m as createBottomFollower
+};

package/dist/src/utils/secure.js

@@ -0,0 +1,36 @@
+var u = () => {
+  const e = globalThis.crypto;
+  if (!e?.getRandomValues) throw new Error("ranuts/secure: Web Crypto is unavailable (needs a browser, Node >= 19, Deno or a Worker)");
+  return e;
+}, c = (e, r) => {
+  const o = new TextEncoder(), s = typeof e == "string" ? o.encode(e) : e, a = typeof r == "string" ? o.encode(r) : r;
+  if (s.length !== a.length) return !1;
+  let n = 0;
+  for (let t = 0; t < s.length; t++) n |= s[t] ^ a[t];
+  return n === 0;
+}, g = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789", l = (e, r = g) => {
+  if (!Number.isInteger(e) || e < 0) throw new RangeError("secureRandomString: length must be a whole number");
+  if (r.length < 2) throw new RangeError("secureRandomString: alphabet needs at least two characters");
+  if (r.length > 256) throw new RangeError("secureRandomString: alphabet must fit in one byte");
+  if (e === 0) return "";
+  const o = u(), s = Math.floor(256 / r.length) * r.length;
+  let a = "";
+  const n = new Uint8Array(Math.min(Math.max(e, 16), 4096));
+  let t = n.length;
+  for (; a.length < e; ) {
+    t >= n.length && (o.getRandomValues(n), t = 0);
+    const i = n[t++];
+    i < s && (a += r[i % r.length]);
+  }
+  return a;
+}, f = (e = 32) => {
+  if (!Number.isInteger(e) || e < 1) throw new RangeError("secureToken: bytes must be a positive whole number");
+  const r = new Uint8Array(e);
+  return u().getRandomValues(r), Array.from(r, (o) => o.toString(16).padStart(2, "0")).join("");
+};
+export {
+  g as UNAMBIGUOUS_ALPHABET,
+  c as safeEqual,
+  l as secureRandomString,
+  f as secureToken
+};

package/dist/src/utils/segment.js

@@ -0,0 +1,43 @@
+var u = (l) => {
+  const n = Array.from({ length: l.length });
+  let i = 0;
+  for (let t = 0; t < l.length; t++)
+    n[t] = i, i += l[t] || 0;
+  return n;
+}, h = (l, n) => {
+  if (l.length === 0) return 0;
+  let i = 0, t = l.length - 1, f = 0;
+  for (; i <= t; ) {
+    const r = i + t >> 1;
+    l[r] <= n ? (f = r, i = r + 1) : t = r - 1;
+  }
+  return f;
+}, c = (l, n, i) => {
+  const t = n + l.length, f = i.map((e) => ({
+    value: e.value,
+    s: Math.max(e.start, n) - n,
+    e: Math.min(e.end, t) - n
+  })).filter((e) => e.e > e.s).sort((e, s) => e.s - s.s || e.e - s.e), r = [], a = (e, s, g) => {
+    r.push({
+      text: l.slice(e, s),
+      start: n + e,
+      end: n + s,
+      value: g
+    });
+  };
+  let o = 0;
+  for (const e of f) {
+    let s = e.s;
+    if (s < o) {
+      if (e.e <= o) continue;
+      s = o;
+    }
+    s > o && a(o, s, null), a(s, e.e, e.value), o = e.e;
+  }
+  return o < l.length && a(o, l.length, null), r.length === 0 && a(0, l.length, null), r;
+};
+export {
+  u as buildOffsets,
+  h as indexForOffset,
+  c as segmentByRanges
+};

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

@@ -1,4 +1,4 @@
-import { SyncHook } from './subscribe';
+import { SyncHook } from "./subscribe.js";
 /** Global event bus: a signal carrying a `subscriber` broadcasts through it on change */
 export declare const subscribers: SyncHook;
 export interface SignalOptions<T> {

package/dist/src/utils/signal.js

@@ -0,0 +1,13 @@
+import { SyncHook as u } from "./subscribe.js";
+var f = new u(), g = (c, o = {}) => {
+  const { subscriber: n, equals: t } = o;
+  let e = c;
+  const i = (r, s) => t === !1 ? !0 : typeof t == "function" ? !t(r, s) : !Object.is(r, s);
+  return [() => e, (r) => {
+    i(e, r) && (e = r, n && f.call(n));
+  }];
+};
+export {
+  g as createSignal,
+  f as subscribers
+};

package/dist/src/utils/speech.js

@@ -0,0 +1,59 @@
+var u = () => {
+  if (typeof window > "u") return;
+  const e = window;
+  return e.SpeechRecognition ?? e.webkitSpeechRecognition;
+}, z = (e) => e === "not-allowed" || e === "service-not-allowed" ? "denied" : e === "no-speech" ? "noSpeech" : e === "aborted" ? "aborted" : "failed", E = () => u() !== void 0, k = (e = {}) => {
+  const { lang: s, continuous: S = !0, interimResults: R = !0, onResult: b, onError: d, onStart: m, onEnd: f } = e;
+  let n = null;
+  const y = () => {
+    n = null, f?.();
+  }, l = {
+    get supported() {
+      return u() !== void 0;
+    },
+    get active() {
+      return n !== null;
+    },
+    start() {
+      const p = u();
+      if (!(!p || n))
+        try {
+          const t = new p();
+          t.lang = typeof s == "function" ? s() : s ?? "", t.continuous = S, t.interimResults = R, t.maxAlternatives = 1;
+          let a = "", r = 0;
+          t.onresult = (o) => {
+            const i = o.results, g = Math.min(o.resultIndex ?? 0, i.length);
+            for (g < r && (r = 0, a = ""); r < g; r++) a += i[r]?.[0]?.transcript ?? "";
+            let h = "", v = !0;
+            for (let c = r; c < i.length; c++) {
+              const w = i[c];
+              h += w?.[0]?.transcript ?? "", w?.isFinal === !1 && (v = !1);
+            }
+            b?.(a + h, v);
+          }, t.onerror = (o) => d?.({
+            kind: z(o.error),
+            detail: o.error
+          }), t.onstart = () => m?.(), t.onend = y, n = t, t.start();
+        } catch (t) {
+          n = null, d?.({
+            kind: "failed",
+            detail: t instanceof Error ? t.message : String(t)
+          }), f?.();
+        }
+    },
+    stop() {
+      n?.stop();
+    },
+    abort() {
+      n?.abort();
+    },
+    toggle() {
+      n ? l.stop() : l.start();
+    }
+  };
+  return l;
+};
+export {
+  k as createSpeechRecognizer,
+  E as isSpeechRecognitionSupported
+};

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.
  *