ranuts 0.4.1-alpha.1 → 0.5.0

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

@@ -1,4 +1,18 @@
-export type Placement = 'top' | 'bottom' | 'left' | 'right';
+/** The side of the anchor a floating panel sits on. */
+export type PlacementSide = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Where the panel lines up along the cross axis: with the anchor's leading
+ * edge, its centre, or its trailing edge. For a `top`/`bottom` placement that
+ * is horizontal (left edge / centre / right edge); for `left`/`right` it is
+ * vertical (top edge / centre / bottom edge).
+ */
+export type PlacementAlign = 'start' | 'center' | 'end';
+/**
+ * A side, optionally suffixed with a cross-axis alignment — the same grammar
+ * Floating UI and Popper use (`bottom`, `bottom-end`, `right-center`, …).
+ * A bare side means `-start`, which is what this module has always done.
+ */
+export type Placement = PlacementSide | `${PlacementSide}-${PlacementAlign}`;
 export interface PlacementRect {
     top: number;
     left: number;
@@ -13,7 +27,7 @@ export interface ComputePlacementOptions {
         width: number;
         height: number;
     };
-    /** Preferred side. Flips to the opposite side when it lacks room and the opposite side has more. */
+    /** Preferred side, optionally with a cross-axis alignment. Flips to the opposite side when it lacks room and the opposite side has more; the alignment is carried across the flip. */
     placement: Placement;
     /** Gap kept between the anchor and the floating panel, in px. */
     offset?: number;
@@ -25,14 +39,37 @@ export interface ComputePlacementOptions {
 export interface ComputedPlacement {
     top: number;
     left: number;
-    /** The side actually used, after flip. */
+    /**
+     * The placement actually used, after flip, in the form the caller asked for:
+     * a bare side stays bare, a suffixed one keeps its suffix. Callers that key a
+     * lookup table off four sides therefore keep working unchanged.
+     */
     placement: Placement;
+    /** The side actually used, after flip — always bare, whatever form `placement` took. */
+    side: PlacementSide;
+    /** The cross-axis alignment actually used. `start` when the caller named none. */
+    align: PlacementAlign;
 }
+/**
+ * @description: Where a floating panel starts along the cross axis, given how
+ * it should line up with its anchor. `start` pins the leading edges together,
+ * `end` the trailing ones, `center` splits the difference. Exported because a
+ * caller that computes its own coordinates -- a panel positioned inside a
+ * custom container rather than the viewport -- still has to align the same way
+ * `computePlacement` does, and two implementations of that would drift.
+ * @param align cross-axis alignment
+ * @param anchorStart anchor's leading edge on that axis (`left` or `top`)
+ * @param anchorSize anchor's size on that axis (`width` or `height`)
+ * @param floatingSize the panel's size on that axis
+ * @return the panel's leading edge on that axis
+ */
+export declare const alignCrossAxis: (align: PlacementAlign, anchorStart: number, anchorSize: number, floatingSize: number) => number;
 /**
  * Position a floating panel relative to an anchor rect: flips to the opposite
  * side when the preferred side doesn't have room and the opposite side has
- * more, then shifts along the cross axis to stay within `boundary`. Mirrors
- * Floating UI's `flip`/`shift` middleware, minus the dependency.
+ * more, aligns along the cross axis as asked, then shifts to stay within
+ * `boundary`. Mirrors Floating UI's `flip`/`shift` middleware, minus the
+ * dependency.
  *
  * Coordinates are viewport-relative throughout (same space as `anchor`); the
  * caller adds `scrollX`/`scrollY` when writing `position: absolute` styles.

package/dist/src/utils/placement.js

@@ -0,0 +1,37 @@
+var y = (s, t, e, f) => s === "end" ? t + e - f : s === "center" ? t + (e - f) / 2 : t, b = () => ({
+  top: 0,
+  left: 0,
+  width: typeof window < "u" ? window.innerWidth : 1 / 0,
+  height: typeof window < "u" ? window.innerHeight : 1 / 0
+}), x = (s) => {
+  const { anchor: t, floating: e, offset: f = 0, padding: p = 8 } = s, n = s.boundary ?? b(), [m, c] = s.placement.split("-"), w = c ?? "start";
+  let i = m;
+  const r = i === "top" || i === "bottom", a = t.width > 0 && t.height > 0 && e.width > 0 && e.height > 0;
+  if (a && r) {
+    const h = n.top + n.height - (t.top + t.height), o = t.top - n.top;
+    i === "bottom" && h < e.height + f && o > h ? i = "top" : i === "top" && o < e.height + f && h > o && (i = "bottom");
+  } else if (a) {
+    const h = n.left + n.width - (t.left + t.width), o = t.left - n.left;
+    i === "right" && h < e.width + f && o > h ? i = "left" : i === "left" && o < e.width + f && h > o && (i = "right");
+  }
+  const g = (h, o, u) => y(w, h, o, u);
+  let d, l;
+  if (i === "bottom" ? (d = t.top + t.height + f, l = g(t.left, t.width, e.width)) : i === "top" ? (d = t.top - e.height - f, l = g(t.left, t.width, e.width)) : i === "right" ? (d = g(t.top, t.height, e.height), l = t.left + t.width + f) : (d = g(t.top, t.height, e.height), l = t.left - e.width - f), a && r) {
+    const h = n.left + p, o = n.left + n.width - e.width - p;
+    o >= h && (l = Math.min(Math.max(l, h), o));
+  } else if (a) {
+    const h = n.top + p, o = n.top + n.height - e.height - p;
+    o >= h && (d = Math.min(Math.max(d, h), o));
+  }
+  return {
+    top: d,
+    left: l,
+    placement: c ? `${i}-${w}` : i,
+    side: i,
+    align: w
+  };
+};
+export {
+  y as alignCrossAxis,
+  x as computePlacement
+};

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.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Bottom-follow for append-only scrollers — a streaming chat transcript, a log tail, a
+ * terminal pane.
+ *
+ * The requirement sounds trivial and is not: stay pinned to the floor as content arrives,
+ * but the instant the reader scrolls up to read something, stop — and re-pin only when
+ * they come back down themselves. Naive implementations fight the reader, because they
+ * cannot tell their own scroll writes apart from the reader's.
+ *
+ * The mechanism here is an **observed-top ledger**. Every programmatic write records the
+ * `scrollTop` it produced. When a scroll event arrives, a position that matches the ledger
+ * is this module's own write echoing back; a position that deviates is the reader. That
+ * covers wheel, touch, scrollbar drag, keyboard, and `scrollIntoView` from unrelated code
+ * uniformly, without listening for any input device — which matters because no set of
+ * device listeners is ever complete.
+ *
+ * Two cases the ledger has to survive:
+ *
+ * - **Shrink-clamp.** When content shrinks, the browser clamps `scrollTop` to the new
+ *   floor without any reader involvement. Comparing against `min(ledger, floor)` treats
+ *   that clamp as the ledger's own value rather than as a reader scroll, so a clamp
+ *   never changes who owns the scroll position — a reader who had scrolled up stays
+ *   unpinned even when the clamp happens to leave them at the floor, and re-pins on
+ *   their next scroll. Re-pinning on a clamp would take control back without input.
+ * - **Growth while pinned.** Appended content moves the floor away. A scroll event that
+ *   the reader did not cause, while pinned, re-snaps to the new floor.
+ *
+ * Scrolling is always instant. Smooth scrolling animates over a moving target, so during
+ * streaming it visibly lags the content and, worse, its own intermediate positions read as
+ * reader input on the next event.
+ */
+/** How to construct a follower. */
+export interface BottomFollowerOptions {
+    /** The element that scrolls. */
+    scrollport: HTMLElement;
+    /**
+     * Elements whose size changes should re-follow the floor while pinned — the content
+     * column, and any sticky footer that resizes outside it. Streaming text grows an
+     * existing node rather than appending one, so growth is observed rather than announced.
+     */
+    observe?: readonly HTMLElement[];
+    /** Distance from the floor still counted as pinned. Defaults to 24. */
+    threshold?: number;
+    /**
+     * Called when the pinned state flips, so a caller can show or hide a "jump to latest"
+     * affordance. Never called for a change the caller itself just made synchronously.
+     */
+    onPinnedChange?: (pinned: boolean) => void;
+}
+/** Imperative bottom-follow controller. */
+export interface BottomFollower {
+    /** Whether new content is currently being followed. */
+    readonly pinned: boolean;
+    /** Scrolls to the floor and pins, regardless of the current state. */
+    toBottom(): void;
+    /**
+     * Follows the floor only if currently pinned. Safe to call on every content change —
+     * a reader who has scrolled up is left alone.
+     */
+    follow(): void;
+    /**
+     * Remembers a row's current offset from the scrollport top, before content is prepended
+     * above it. Capture a row that is actually on screen, so the restore keeps what the
+     * reader is looking at exactly where it was.
+     *
+     * @param row The row to keep still.
+     */
+    captureAnchor(row: HTMLElement): void;
+    /**
+     * Restores the captured row to its captured offset, then forgets it.
+     *
+     * @param resolve Re-resolves the row after the prepend, for callers that replace nodes
+     *   rather than reuse them. Omit when the captured element is still in the document.
+     * @returns Whether an anchor was restored.
+     */
+    restoreAnchor(resolve?: () => HTMLElement | null): boolean;
+    /** Discards any captured anchor without restoring it. */
+    releaseAnchor(): void;
+    /** Removes the scroll listener and disconnects the resize observer. */
+    destroy(): void;
+}
+/**
+ * Creates a bottom-follow controller for one scrollport.
+ *
+ * The controller starts pinned, which is what an append-only view wants on first paint and
+ * after a reload. To restore a remembered position instead, set `scrollTop` before or
+ * after construction and the first scroll event will settle the pinned state from the
+ * geometry.
+ *
+ * @param options Scrollport, elements to observe, and threshold.
+ * @returns The controller; call `destroy` to release its listeners.
+ */
+export declare function createBottomFollower(options: BottomFollowerOptions): BottomFollower;

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
+};