@dvirus-js/utils 0.0.1

package/index.js

@@ -0,0 +1,837 @@
+function D(t) {
+  return t.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function W(t, r) {
+  const e = D(t);
+  switch (r) {
+    case "lowercase":
+      return e.toLowerCase();
+    case "UPPERCASE":
+      return e.toUpperCase();
+    case "Title Case":
+      return e.split(" ").map(
+        (n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()
+      ).join(" ");
+    case "kebab-case":
+      return e.replace(/\s+/g, "-");
+    case "snake_case":
+      return e.replace(/\s+/g, "_");
+    case "camelCase": {
+      const n = e.split(" ");
+      return n.length === 0 ? "" : n[0]?.toLowerCase() + n.slice(1).map(
+        (o) => o.charAt(0).toUpperCase() + o.slice(1).toLowerCase()
+      ).join("");
+    }
+    case "PascalCase":
+      return e.split(" ").map(
+        (n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()
+      ).join("");
+    case "dot.case":
+      return e.replace(/\s+/g, ".");
+    case "path/case":
+      return e.replace(/\s+/g, "/");
+    case "Sentence case":
+      return e.replace(/(^\s*\w|[.!?]\s*\w)/g, (n) => n.toUpperCase()).replace(/\bi\b/g, "I");
+    case "Header-Case":
+      return e.split(" ").map(
+        (n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()
+      ).join("-");
+    case "reverse":
+      return e.split("").reverse().join("");
+    default:
+      throw new Error(`Unsupported case type: ${r}`);
+  }
+}
+async function Y(t) {
+  try {
+    return [await t, null];
+  } catch (r) {
+    return [null, r];
+  }
+}
+function E(t) {
+  try {
+    return [t(), null];
+  } catch (r) {
+    return [null, r];
+  }
+}
+const F = {
+  /**
+   * Makes a GET request to the specified URL.
+   *
+   * @param {string} url - The URL to send the GET request to.
+   * @param {RequestInit} [options] - Optional request options.
+   * @returns {Promise<any>} The response data.
+   * @throws {Error} If the response is not ok.
+   */
+  get: async function(t, r) {
+    const e = await fetch(t, r);
+    return await S(e);
+  },
+  /**
+   * Makes a POST request to the specified URL with the given data.
+   *
+   * @template R
+   * @param {string} url - The URL to send the POST request to.
+   * @param {unknown} data - The data to send in the request body.
+   * @param {RequestInit} [options] - Optional request options.
+   * @returns {Promise<R>} The response data.
+   * @throws {Error} If the response is not ok.
+   */
+  post: async function(t, r, e) {
+    const n = await fetch(t, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...e?.headers
+      },
+      body: JSON.stringify(r),
+      ...e
+    });
+    return await S(n);
+  },
+  /**
+   * Makes a DELETE request to the specified URL with the given ID.
+   *
+   * @template R
+   * @param {string} url - The URL to send the DELETE request to.
+   * @param {string} id - The ID to send in the request body.
+   * @param {RequestInit} [options] - Optional request options.
+   * @returns {Promise<R>} The response data.
+   * @throws {Error} If the response is not ok.
+   */
+  delete: async function(t, r, e) {
+    const n = await fetch(t, {
+      method: "DELETE",
+      headers: {
+        "Content-Type": "application/json",
+        ...e?.headers
+      },
+      body: JSON.stringify({ id: r }),
+      ...e
+    });
+    return await S(n);
+  },
+  /**
+   * Makes a PATCH request to the specified URL with the given data.
+   *
+   * @template R
+   * @param {string} url - The URL to send the PATCH request to.
+   * @param {unknown} data - The data to send in the request body.
+   * @param {RequestInit} [options] - Optional request options.
+   * @returns {Promise<R>} The response data.
+   * @throws {Error} If the response is not ok.
+   */
+  patch: async function(t, r, e) {
+    const n = await fetch(t, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        ...e?.headers
+      },
+      body: JSON.stringify(r),
+      ...e
+    });
+    return await S(n);
+  },
+  /**
+   * Makes a PUT request to the specified URL with the given data.
+   *
+   * @template R
+   * @param {string} url - The URL to send the PUT request to.
+   * @param {unknown} data - The data to send in the request body.
+   * @param {RequestInit} [options] - Optional request options.
+   * @returns {Promise<R>} The response data.
+   * @throws {Error} If the response is not ok.
+   */
+  put: async function(t, r, e) {
+    const n = await fetch(t, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        ...e?.headers
+      },
+      body: JSON.stringify(r),
+      ...e
+    });
+    return await S(n);
+  }
+};
+async function S(t) {
+  if (!t.ok) throw new Error(`Error: ${t.statusText}`);
+  return await t.json();
+}
+function ee(t, r) {
+  const e = {};
+  return t?.forEach((n, o) => {
+    const s = r(n, o, t)?.toString();
+    s && (e[s] ??= [], e[s].push(n));
+  }), e;
+}
+async function te(t) {
+  return await new Promise((r) => setTimeout(r, t));
+}
+function re(t, r, e) {
+  return r < t ? t : r > e ? e : r;
+}
+function ne(t, r) {
+  let e;
+  return (...n) => {
+    clearTimeout(e), e = setTimeout(() => t(...n), r);
+  };
+}
+function se(t, r) {
+  if (!r || typeof r != "string" || typeof t != "object" || t === null)
+    return;
+  const e = r.split(".");
+  function n(o, s) {
+    if (!s || typeof s != "object")
+      return;
+    const a = o[0];
+    if (a in s)
+      return o.length === 1 ? s[a] : n(o.slice(1), s[a]);
+  }
+  return n(e, t);
+}
+class g {
+  #e = null;
+  #t = null;
+  /**
+   * Creates a successful result.
+   * @param {T} val - The success value.
+   * @returns {Result<T, never>} A Result instance representing a success.
+   */
+  static ok(r) {
+    return new g(r, null);
+  }
+  /**
+   * Creates a failed result.
+   * @param {E | string} err - The error value or message.
+   * @returns {Result<never, E>} A Result instance representing a failure.
+   */
+  static err(r) {
+    return typeof r == "string" ? new g(null, new Error(r)) : new g(null, r);
+  }
+  /**
+   * Wraps a promise in a Result.
+   * @param {Promise<T>} promise - The promise to wrap.
+   * @returns {Promise<Result<T, E>>} A promise that resolves to a Result.
+   */
+  static async promise(r) {
+    return r.then((e) => g.ok(e ?? "void")).catch((e) => g.err(e));
+  }
+  /**
+   * Wraps a function call in a Result.
+   * @param {(...args: any[]) => T} func - The function to call.
+   * @param {...any[]} args - The arguments to pass to the function.
+   * @returns {Result<T, E>} A Result instance representing the function call result.
+   */
+  static func(r, ...e) {
+    try {
+      const n = r(...e);
+      return g.ok(n);
+    } catch (n) {
+      return g.err(n);
+    }
+  }
+  /**
+   * @param {T | null} ok - The success value.
+   * @param {E | null} err - The error value.
+   * @throws {Error} If both ok and err are provided or neither is provided.
+   */
+  constructor(r, e) {
+    if (!r && !e)
+      throw new Error("Result must be initialized with either an ok or an err value");
+    if (r && e)
+      throw new Error("Result can't be initialized with both an ok and an err value");
+    r != null ? this.#e = r : this.#t = e;
+  }
+  /**
+   * Gets the success value, throwing an error if the result is a failure.
+   * @returns {T} The success value.
+   * @throws {Error} If the result is a failure.
+   */
+  get value() {
+    return this.expect("add error handling");
+  }
+  /**
+   * Unwraps the result, returning the success value or throwing the error.
+   * @returns {T} The success value.
+   * @throws {E} If the result is a failure.
+   */
+  unwrap() {
+    if (this.isOk())
+      return this.#e;
+    throw this.isErr() ? this.#t : new Error("Unknown error");
+  }
+  /**
+   * Unwraps the result, returning the success value or a default value if the result is a failure.
+   * @param {T} defaultValue - The default value to return if the result is a failure.
+   * @returns {T} The success value or the default value.
+   */
+  unwrapOr(r) {
+    return this.isOk() ? this.#e : r;
+  }
+  /**
+   * Gets the success value, throwing a custom error message if the result is a failure.
+   * @param {string} msg - The custom error message.
+   * @returns {T} The success value.
+   * @throws {Error} If the result is a failure.
+   */
+  expect(r) {
+    if (this.isOk())
+      return this.#e;
+    if (this.isErr()) {
+      const e = this.#t;
+      throw new Error(r + `:
+` + e.message);
+    }
+    throw new Error(r);
+  }
+  /**
+   * Checks if the result is a success.
+   * @returns {boolean} True if the result is a success, false otherwise.
+   */
+  isOk() {
+    return this.#e != null;
+  }
+  /**
+   * Checks if the result is a failure.
+   * @returns {boolean} True if the result is a failure, false otherwise.
+   */
+  isErr() {
+    return this.#t != null;
+  }
+  /**
+   * Gets the error value.
+   * @returns {E | null} The error value, or null if the result is a success.
+   */
+  get error() {
+    return this.#t;
+  }
+}
+function oe(t, r = []) {
+  return t == null ? r : Array.isArray(t) ? t : [t];
+}
+const z = /* @__PURE__ */ Symbol("SIGNAL"), ae = (t) => typeof t == "function" && z in t, h = [], ie = (t) => {
+  const r = h.splice(0, h.length);
+  try {
+    return t();
+  } finally {
+    h.push(...r);
+  }
+}, A = (t, r) => {
+  const e = /* @__PURE__ */ new Set();
+  let n = 0;
+  const o = () => {
+    const l = h[h.length - 1];
+    l && (e.add(l.setDirty), l.addSource(() => {
+      e.delete(l.setDirty);
+    }));
+  }, s = (l) => {
+    for (const y of Array.from(e)) y(l);
+  }, a = () => n > 0;
+  return { read: Object.assign(() => (o(), t()), {
+    [z]: !0,
+    subscribe: (l) => (e.add(l), n++, r?.(), () => {
+      e.delete(l), n--;
+    })
+  }), notify: s, hasSubscribers: a };
+}, C = (t) => {
+  let r = t;
+  const { read: e, notify: n } = A(() => r);
+  return Object.assign(e, {
+    set: (o) => {
+      r !== o && (r = o, n(o));
+    },
+    update: (o) => {
+      const s = o(r);
+      r !== s && (r = s, n(s));
+    },
+    asReadonly: () => e
+  });
+}, k = (t) => {
+  const r = /* @__PURE__ */ new Set();
+  let e = !1, n = null, o = !1;
+  const s = () => {
+    if (o = !1, e) return;
+    n && (n(), n = null), r.forEach((i) => i()), r.clear();
+    const a = (i) => {
+      n = i;
+    };
+    h.push({
+      setDirty: () => {
+        !e && !o && (o = !0, queueMicrotask(s));
+      },
+      addSource: (i) => r.add(i)
+    }), t(a), h.pop();
+  };
+  return s(), {
+    destroy() {
+      e = !0, n && (n(), n = null), r.forEach((a) => a()), r.clear();
+    }
+  };
+}, L = (t) => {
+  const r = /* @__PURE__ */ new Set();
+  let e, n = !0, o = () => {
+  };
+  const s = () => {
+    r.forEach((c) => c()), r.clear(), h.push({
+      setDirty: () => {
+        if (n) return;
+        n = !0;
+        const c = e;
+        s(), e !== c && o(e);
+      },
+      addSource: (c) => r.add(c)
+    }), e = t(), n = !1, h.pop();
+  }, { read: a, notify: i } = A(
+    () => (n && s(), e),
+    () => {
+      n && s();
+    }
+  );
+  return o = i, a;
+};
+function ce(t) {
+  const r = typeof t == "function", e = r ? void 0 : t.source, n = r ? t : t.computation, o = /* @__PURE__ */ new Set();
+  let s, a = !0, i = !1, c, l = () => {
+  };
+  const y = () => {
+    if (o.forEach((u) => u()), o.clear(), h.push({
+      setDirty: () => {
+        if (a) return;
+        a = !0, i = !1;
+        const u = s;
+        y(), s !== u && l(s);
+      },
+      addSource: (u) => o.add(u)
+    }), r)
+      s = n();
+    else {
+      const u = e?.();
+      s = n(u, c), c = { source: u, value: s };
+    }
+    a = !1, h.pop();
+  }, { read: v, notify: d } = A(
+    () => (a && !i && y(), s),
+    () => {
+      a && !i && y();
+    }
+  );
+  l = d;
+  const b = Object.assign(v, {
+    set: (u) => {
+      s !== u && (s = u, i = !0, a = !1, d(u));
+    },
+    update: (u) => {
+      a && !i && y(), b.set(u(s));
+    },
+    asReadonly: () => v
+  });
+  return b;
+}
+class G extends Error {
+  constructor(r) {
+    const e = r instanceof Error ? `:
+${r.message}` : "";
+    super(`Cannot read resource value while in error state${e}`, { cause: r }), this.name = "ResourceErrorState";
+  }
+}
+function le(t) {
+  const r = C(void 0), e = C("idle"), n = C(void 0), o = L(() => e() === "loading"), s = C(0), a = L(() => {
+    if (e() === "error")
+      throw new G(n());
+    return r();
+  }), i = (d) => {
+    r.set(d), n.set(void 0), e.set("resolved");
+  }, c = (d) => {
+    r.update(d), n.set(void 0), e.set("resolved");
+  }, l = "params" in t;
+  if ("stream" in t) {
+    const d = C(void 0), b = k((p) => {
+      s();
+      const f = new AbortController();
+      p(() => f.abort());
+      const I = l ? t.params() : void 0;
+      e.set("loading"), n.set(void 0);
+      const N = t.stream, _ = N(l ? {
+        params: I,
+        abortSignal: f.signal
+      } : {
+        abortSignal: f.signal
+      });
+      d.set(_);
+    }), u = k(() => {
+      const p = d();
+      if (!p) return;
+      const f = p();
+      f && ("error" in f && f.error !== void 0 ? (n.set(f.error), e.set("error")) : "value" in f && (r.set(f.value), e.set("resolved")));
+    });
+    return {
+      value: a,
+      status: e,
+      error: n,
+      isLoading: o,
+      set: i,
+      update: c,
+      reload: () => {
+        s.update((p) => p + 1);
+      },
+      destroy: () => {
+        b.destroy(), u.destroy();
+      }
+    };
+  }
+  const v = k((d) => {
+    s();
+    const b = l ? t.params() : void 0;
+    e.set("loading"), n.set(void 0);
+    const u = new AbortController();
+    d(() => u.abort());
+    const p = l ? { params: b, abortSignal: u.signal } : { abortSignal: u.signal };
+    t.loader(p).then(
+      (f) => {
+        u.signal.aborted || (r.set(f), e.set("resolved"));
+      },
+      (f) => {
+        u.signal.aborted || (n.set(f), e.set("error"));
+      }
+    );
+  });
+  return {
+    value: a,
+    status: e,
+    error: n,
+    isLoading: o,
+    set: i,
+    update: c,
+    reload: () => {
+      s.update((d) => d + 1);
+    },
+    destroy: () => v.destroy()
+  };
+}
+const $ = /* @__PURE__ */ new Map([
+  ["b", "b"],
+  ["i", "i"],
+  ["u", "u"],
+  ["s", "s"],
+  ["mark", "mark"],
+  ["small", "small"],
+  ["strong", "b"],
+  ["em", "i"],
+  ["sup", "sup"],
+  ["sub", "sub"],
+  ["h1", "h1"],
+  ["h2", "h2"],
+  ["h3", "h3"],
+  ["h4", "h4"],
+  ["h5", "h5"],
+  ["h6", "h6"],
+  ["code", "code"],
+  ["p", "p"],
+  ["div", "div"],
+  ["ul", "ul"],
+  ["ol", "ol"],
+  ["li", "li"]
+]), T = /* @__PURE__ */ new Set([
+  "div",
+  "p",
+  "ul",
+  "ol",
+  "li",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6"
+]);
+let O = "rtp-";
+function x() {
+  return O;
+}
+function V(t) {
+  O = t;
+}
+const j = /* @__PURE__ */ new Map([
+  ["br", "br"],
+  ["hr", "hr"]
+]), w = /* @__PURE__ */ new Map([
+  ["b", /* @__PURE__ */ new Map([["font-weight", "bold"]])],
+  ["i", /* @__PURE__ */ new Map([["font-style", "italic"]])],
+  ["u", /* @__PURE__ */ new Map([["text-decoration", "underline"]])],
+  ["s", /* @__PURE__ */ new Map([["text-decoration", "line-through"]])],
+  ["mark", /* @__PURE__ */ new Map([["background-color", "yellow"]])],
+  ["small", /* @__PURE__ */ new Map([["font-size", "smaller"]])],
+  ["strong", /* @__PURE__ */ new Map([["font-weight", "bold"]])],
+  ["em", /* @__PURE__ */ new Map([["font-style", "italic"]])],
+  [
+    "sub",
+    /* @__PURE__ */ new Map([
+      ["vertical-align", "sub"],
+      ["font-size", "smaller"]
+    ])
+  ],
+  [
+    "sup",
+    /* @__PURE__ */ new Map([
+      ["vertical-align", "super"],
+      ["font-size", "smaller"]
+    ])
+  ],
+  [
+    "h1",
+    /* @__PURE__ */ new Map([
+      ["font-size", "2em"],
+      ["font-weight", "bold"]
+    ])
+  ],
+  [
+    "h2",
+    /* @__PURE__ */ new Map([
+      ["font-size", "1.5em"],
+      ["font-weight", "bold"]
+    ])
+  ],
+  [
+    "h3",
+    /* @__PURE__ */ new Map([
+      ["font-size", "1.17em"],
+      ["font-weight", "bold"]
+    ])
+  ],
+  [
+    "h4",
+    /* @__PURE__ */ new Map([
+      ["font-size", "1em"],
+      ["font-weight", "bold"]
+    ])
+  ],
+  [
+    "h5",
+    /* @__PURE__ */ new Map([
+      ["font-size", "0.83em"],
+      ["font-weight", "bold"]
+    ])
+  ],
+  [
+    "h6",
+    /* @__PURE__ */ new Map([
+      ["font-size", "0.67em"],
+      ["font-weight", "bold"]
+    ])
+  ],
+  ["code", /* @__PURE__ */ new Map([["font-family", "monospace"]])],
+  ["p", /* @__PURE__ */ new Map([["margin-block", "1em"]])],
+  ["div", /* @__PURE__ */ new Map([["display", "block"]])],
+  ["ul", /* @__PURE__ */ new Map([["padding-left", "1.5em"]])],
+  ["ol", /* @__PURE__ */ new Map([["padding-left", "1.5em"]])],
+  ["li", /* @__PURE__ */ new Map([["margin-block", "0.5em"]])],
+  [
+    "br",
+    /* @__PURE__ */ new Map([
+      ["display", "block"],
+      ["height", "1em"]
+    ])
+  ],
+  [
+    "hr",
+    /* @__PURE__ */ new Map([
+      ["display", "block"],
+      ["border", "0"],
+      ["border-top", "1px solid #ccc"],
+      ["border-color", "green"],
+      ["margin", "1em 0"]
+    ])
+  ]
+]), M = (t, r, e, n, o) => {
+  const s = t.filter((i) => !T.has(i)), a = t.filter((i) => T.has(i));
+  return {
+    tagNames: t.join(","),
+    tagNamesList: t,
+    text: o ?? r.slice(e, n),
+    style: s.map(
+      (i) => [...w.get(i)?.entries() ?? []].map(([c, l]) => `${c}: ${l}`).join("; ")
+    ).filter(Boolean).join("; "),
+    styleObject: Object.fromEntries(
+      s.flatMap((i) => Array.from(w.get(i) ?? []))
+    ),
+    containerTagNames: a,
+    cssClass: s.map((i) => `${x()}${i}`).join(" ")
+  };
+}, J = () => [...$.keys()].join("|"), H = () => [...j.keys()].join("|"), Z = () => new RegExp(
+  `<\\/?(${J()})>|<(${H()})\\s*/?>`,
+  "gi"
+);
+function P(t, r) {
+  const e = w.get(t) ?? /* @__PURE__ */ new Map();
+  Object.entries(r).forEach(([n, o]) => e.set(n, o)), w.set(t, e);
+}
+function B() {
+  const t = [];
+  for (const [r, e] of w) {
+    if (e.size === 0) continue;
+    const n = [...e.entries()].map(([o, s]) => `  ${o}: ${s};`).join(`
+`);
+    t.push(`.${x()}${r} {
+${n}
+}`);
+  }
+  return t.join(`
+`);
+}
+function q() {
+  if ("document" in globalThis) {
+    const t = B(), r = globalThis, e = r.document.getElementById(
+      "html-text-parser-styles"
+    );
+    if (e) {
+      e.textContent = t;
+      return;
+    }
+    const n = r.document.createElement("style");
+    n.textContent = t, n.setAttribute("id", "html-text-parser-styles"), r.document.head.appendChild(n);
+    return;
+  }
+  console.warn(
+    "[html-text-parser] Cannot inject stylesheet: document is not available."
+  );
+}
+function X(t) {
+  const r = [];
+  let e;
+  for (const n of t) {
+    const o = n.containerTagNames.join(","), s = e?.containerTagNames.join(",");
+    o !== s && (e = {
+      containerTagNames: n.containerTagNames,
+      cssClass: n.containerTagNames.map((a) => `${x()}${a}`).join(" "),
+      style: n.containerTagNames.map(
+        (a) => [...w.get(a)?.entries() ?? []].map(([i, c]) => `${i}: ${c}`).join("; ")
+      ).filter(Boolean).join("; "),
+      styleObject: Object.fromEntries(
+        n.containerTagNames.flatMap(
+          (a) => Array.from(w.get(a) ?? [])
+        )
+      ),
+      segments: []
+    }, r.push(e)), e.segments.push(n);
+  }
+  return r;
+}
+function m(t) {
+  const r = [], e = /* @__PURE__ */ new Map();
+  let n = 0;
+  for (const o of t.matchAll(Z())) {
+    const s = o.index;
+    s > n && r.push(
+      M([...e.keys()], t, n, s)
+    );
+    const a = o[2]?.toLowerCase();
+    if (a && j.has(a)) {
+      r.push(
+        M(
+          [...e.keys(), a],
+          t,
+          n,
+          s,
+          ""
+        )
+      ), n = s + o[0].length;
+      continue;
+    }
+    const i = o[0][1] === "/", c = $.get(o[1]?.toLowerCase() ?? "") ?? "";
+    if (i) {
+      const l = (e.get(c) ?? 1) - 1;
+      l <= 0 ? e.delete(c) : e.set(c, l);
+    } else
+      e.set(c, (e.get(c) ?? 0) + 1);
+    n = s + o[0].length;
+  }
+  return n < t.length && r.push(
+    M(
+      [...e.keys()],
+      t,
+      n,
+      t.length
+    )
+  ), r;
+}
+function R(t) {
+  if (Array.isArray(t)) {
+    t.forEach((e) => {
+      R(e);
+    });
+    return;
+  }
+  const r = t.tagName ?? t.tag;
+  $.set(t.tag, r), t.style != null && Object.keys(t.style).length && P(r, t.style);
+}
+function U(t) {
+  if (Array.isArray(t)) {
+    t.forEach((e) => {
+      U(e);
+    });
+    return;
+  }
+  const r = t.tagName ?? t.tag;
+  j.set(t.tag, r), t.style != null && Object.keys(t.style).length && P(r, t.style);
+}
+m.setTag = R;
+m.setSelfClosingTag = U;
+m.setBlockTag = (t) => T.add(t);
+m.removeBlockTag = (t) => T.delete(t);
+m.setCssClassPrefix = V;
+"document" in globalThis && (m.generateStylesheet = q);
+m.getStylesheet = B;
+m.groupByBlocks = X;
+function K(t, r, e) {
+  function n(o) {
+    const [s, a] = E(() => e ? e(o) : o);
+    if (a) throw new Error(`Error transforming value for ${t}: ${a.message}`);
+    if (!r(s)) throw new Error(`"${o}" is not a valid ${t}`);
+    return s;
+  }
+  return n.from = (o) => {
+    const [s, a] = E(() => e ? e(o) : o);
+    if (!a)
+      return r(s) ? s : void 0;
+  }, n.is = (o) => {
+    const s = E(() => e ? e(o) : o)[0] ?? o;
+    return r(s);
+  }, n;
+}
+const Q = /^\d+$/, ue = K(
+  "NumericString",
+  (t) => Q.test(String(t)),
+  (t) => String(t)
+);
+export {
+  ue as NumericString,
+  g as Result,
+  z as SIGNAL,
+  re as clamp,
+  L as computed,
+  W as convertCase,
+  K as createBrand,
+  ne as debounce,
+  te as delay,
+  k as effect,
+  se as getProp,
+  ee as groupBy,
+  F as http,
+  ae as isSignal,
+  ce as linkedSignal,
+  D as normalizeString,
+  m as parseRichText,
+  le as resource,
+  R as setRichTextTag,
+  U as setSelfClosingTag,
+  C as signal,
+  oe as toArray,
+  E as tryCatch,
+  Y as tryCatchAsync,
+  ie as untracked
+};