@tktb-tess/util-fns 0.9.2-alpha.0 → 0.9.2-alpha.1

package/dist/bundle.esm.js

@@ -0,0 +1,896 @@
+const v = new TextEncoder(), Y = (n, t) => [n].includes(t), g = (n, t) => {
+  if (typeof n != typeof t) return !1;
+  const e = Object.prototype.toString.call(n), r = Object.prototype.toString.call(t);
+  if (e !== r) return !1;
+  if (typeof n == "string" || typeof n == "bigint" || typeof n == "boolean" || typeof n == "symbol" || n == null)
+    return n === t;
+  if (typeof n == "number")
+    return n !== n && t !== t || n === t;
+  if (typeof n == "function")
+    return !1;
+  if (Array.isArray(n) && Array.isArray(t)) {
+    if (n.length !== t.length) return !1;
+    for (let s = 0; s < n.length; s++)
+      if (!g(n[s], t[s])) return !1;
+    return !0;
+  }
+  if (n instanceof Set && t instanceof Set) {
+    const s = [...n.values()], o = [...t.values()];
+    return !!g(s, o);
+  }
+  if (n instanceof Map && t instanceof Map) {
+    const s = [...n.keys()], o = [...t.keys()];
+    if (!g(s, o)) return !1;
+    const i = [...n.values()], c = [...t.values()];
+    return !!g(i, c);
+  }
+  if (e === "[object Object]") {
+    const s = n, o = t, i = Object.keys(s), c = Object.keys(o);
+    for (const a of i) {
+      const l = c.find((d) => d === a);
+      if (l === void 0) return !1;
+      const [f, h] = [s[a], o[l]];
+      if (!g(f, h)) return !1;
+    }
+    return !0;
+  }
+  throw Error(`comparing these objects is unavailable: ${n}, ${t}`, {
+    cause: [n, t]
+  });
+}, G = () => {
+  let n, t;
+  return {
+    promise: new Promise((r, s) => {
+      n = r, t = s;
+    }),
+    resolve: n,
+    reject: t
+  };
+}, H = (n) => new Promise((t) => {
+  setTimeout(() => t(), n);
+}), X = (n) => (...t) => () => n(...t), Z = (n) => {
+  const t = [];
+  let e = [], r = "", s = !1;
+  for (let o = 0; o < n.length; o++) {
+    const i = n[o];
+    i === '"' && (o === 0 || n[o - 1] !== "\\") ? s = !s : i === "," && !s ? (e.push(r.trim()), r = "") : i === `
+` && !s ? (e.push(r.trim()), t.push(e), e = [], r = "") : r += i;
+  }
+  return e.push(r.trim()), t.push(e), t;
+}, Q = async (n, t) => {
+  const e = v.encode(n), r = await crypto.subtle.digest(t, e);
+  return new Uint8Array(r);
+}, tt = () => !!globalThis.process && typeof process.version < "u" && typeof process.versions.node < "u", nt = (n) => encodeURIComponent(n).replace(
+  /[!'()*]/g,
+  (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`
+), et = (n) => {
+  if (n.includes("+"))
+    throw Error("An input string has '+'");
+  return decodeURIComponent(n);
+}, rt = async (n, t) => {
+  const r = new Blob([n]).stream().pipeThrough(new CompressionStream(t));
+  return new Response(r).bytes();
+}, st = async (n, t) => {
+  const r = new Blob([n]).stream().pipeThrough(new DecompressionStream(t));
+  return new Response(r).bytes();
+}, ot = (n, t) => Math.floor(Math.random() * (t - n) + n), m = (n, t) => {
+  t < 0n && (t *= -1n);
+  const e = n % t;
+  return e < 0n ? e + t : e;
+}, E = (n, t = !1) => {
+  if (!Number.isFinite(n)) throw Error("`length` is not a valid number");
+  if (n <= 0) throw Error("`length` must be positive");
+  const e = Math.ceil(n / 8), r = crypto.getRandomValues(new Uint8Array(e));
+  let s = Array.from(r, (o) => o.toString(2).padStart(8, "0")).join("").slice(0, n);
+  return t && (s = s.replace(/^\d/, "1")), BigInt("0b" + s);
+}, _ = (n, t) => {
+  if (n >= t) throw Error("rangeError");
+  const e = t - n, r = e.toString(2).length, s = (() => {
+    for (let i = 0; i < 1e5; i++) {
+      const c = E(r);
+      if (c >= p(2n, BigInt(r), e))
+        return c % e;
+    }
+    throw Error("Failed to generate a random bigint");
+  })();
+  return n + s;
+}, p = (n, t, e) => {
+  if (e < 1n) throw Error("`mod` must be positive");
+  if (t < 0n) throw Error("`power` must not be negative");
+  if (n = m(n, e), e === 1n) return 0n;
+  if (n % e === 1n || n % e === 0n) return n;
+  if (n === e - 1n) return t & 1n ? e - 1n : 1n;
+  let r = 1n;
+  for (; t > 0n; )
+    t & 1n && (r = r * n % e), n = n * n % e, t >>= 1n;
+  return r;
+}, j = (n, t) => {
+  if (n === 0n && t === 0n) return { x: 0n, y: 0n, gcd: 0n };
+  if (n === 0n)
+    return t > 0n ? { x: 0n, y: -1n, gcd: t } : { x: 0n, y: 1n, gcd: -t };
+  if (t === 0n)
+    return n > 0n ? { x: 1n, y: 0n, gcd: n } : { x: -1n, y: 0n, gcd: -n };
+  let [e, r, s] = [1n, 0n, n], [o, i, c] = [0n, -1n, t];
+  for (; ; ) {
+    const a = s / c, l = s - a * c;
+    if (l === 0n) break;
+    [e, o] = [o, e - a * o], [r, i] = [i, r - a * i], [s, c] = [c, l];
+  }
+  return c < 0n && (o *= -1n, i *= -1n, c *= -1n), { x: o, y: i, gcd: c };
+}, b = (n, t) => {
+  if (n >= t) return 1n;
+  const e = BigInt((t - 2n).toString(2).length), r = (t - n) / 2n;
+  if (e * r < 63n) {
+    let c = n;
+    for (let a = n + 2n; a < t; a += 2n)
+      c *= a;
+    return c;
+  }
+  const s = n + r | 1n, o = b(n, s), i = b(s, t);
+  return o * i;
+}, C = (n) => {
+  let t = 3n, e = 1n, r = 1n;
+  const s = BigInt(n.toString(2).length) - 1n;
+  for (let o = s - 1n; o > -1n; --o) {
+    const i = (n >> o) + 1n | 1n;
+    r *= b(t, i), t = i, e *= r;
+  }
+  return e;
+}, it = (n) => {
+  if (n < 0n) throw Error("'n' must be non-negative");
+  if (n === 0n) return 1n;
+  const t = n - BigInt(n.toString(2).match(/1/g)?.length ?? 0);
+  return C(n) << t;
+}, F = (n, t) => (n >>> (t & 31) | n << (-t & 31)) >>> 0, I = (n, t) => BigInt.asUintN(64, n >> (t & 63n) | n << (-t & 63n)), U = (n, t) => {
+  if (t < 1n || t % 2n === 0n)
+    throw Error("`n` is invalid");
+  for (; n < 0n; )
+    n += t;
+  n %= t;
+  let e = 1n;
+  for (; n !== 0n; ) {
+    for (; n % 2n === 0n; ) {
+      n /= 2n;
+      const r = t % 8n;
+      (r === 3n || r === 5n) && (e *= -1n);
+    }
+    [n, t] = [t, n], n % 4n === 3n && t % 4n === 3n && (e *= -1n), n %= t;
+  }
+  return t === 1n ? e : 0n;
+}, P = (n) => {
+  if (n < 0n) return !1;
+  if (n === 0n) return !0;
+  let t = 1n, e = n;
+  for (; t + 1n < e; ) {
+    const r = (t + e) / 2n;
+    r ** 2n < n ? t = r : e = r;
+  }
+  return n === t ** 2n || n === (t + 1n) ** 2n;
+}, O = (n) => {
+  if (n <= 1n) return !1;
+  if (n % 2n === 0n) return n === 2n;
+  let t = n - 1n, e = 0n;
+  for (; t % 2n === 0n; )
+    t >>= 1n, e += 1n;
+  const [r, s] = [t, e];
+  let i = p(2n, r, n);
+  if (i === 1n) return !0;
+  for (let c = 0n; c < s; c++) {
+    if (i === n - 1n) return !0;
+    i = i * i % n;
+  }
+  return !1;
+}, V = (n) => {
+  let t = 5n, e = U(t, n);
+  for (; e > 0n; ) {
+    if (t = t > 0n ? t + 2n : t - 2n, t *= -1n, t === -15n && P(n))
+      return [0n, 0n];
+    e = U(t, n);
+  }
+  return [t, e];
+}, w = (n, t) => (n & 1n) === 1n ? m(n + t >> 1n, t) : m(n >> 1n, t), $ = (n, t, e, r) => {
+  let s = 1n, o = e;
+  const i = n.toString(2).slice(1);
+  for (const c of i)
+    [s, o] = [m(s * o, t), w(o * o + r * s * s, t)], c === "1" && ([s, o] = [w(e * s + o, t), w(r * s + e * o, t)]);
+  return [s, o];
+}, k = (n, t, e, r) => {
+  if (n % 2n !== 1n) throw Error("`n` must be odd");
+  let s = n + 1n, o = 0n;
+  for (; s % 2n === 0n; )
+    s >>= 1n, o += 1n;
+  const [i, c] = $(s, n, e, t);
+  let a = c;
+  if (i === 0n) return !0;
+  r = p(r, s, n);
+  for (let l = 0n; l < o; l++) {
+    if (a === 0n) return !0;
+    a = m(a * a - 2n * r, n), r = p(r, 2n, n);
+  }
+  return !1;
+}, x = (n) => {
+  if (n <= 1n) return !1;
+  if (n % 2n === 0n) return n === 2n;
+  const t = [
+    2n,
+    3n,
+    5n,
+    7n,
+    11n,
+    13n,
+    17n,
+    19n,
+    23n,
+    29n,
+    31n,
+    37n,
+    41n,
+    43n,
+    47n,
+    53n,
+    59n,
+    61n,
+    67n,
+    71n,
+    73n,
+    79n,
+    83n,
+    89n,
+    97n,
+    101n
+  ];
+  for (const o of t)
+    if (n % o === 0n)
+      return n === o;
+  if (!O(n))
+    return !1;
+  const [e, r] = V(n);
+  if (r === 0n) return !1;
+  const s = (1n - e) / 4n;
+  return k(n, e, 1n, s);
+}, ct = (n, t) => {
+  if (t < 2n)
+    throw Error("noPrimesFound");
+  for (let r = 0; r < 1e5; r++) {
+    const s = _(n, t);
+    if (x(s)) return s;
+  }
+  throw Error("noPrimesFound");
+}, at = (n, t = !1) => {
+  if (n < 2)
+    throw Error("noPrimesFound");
+  for (let r = 0; r < 1e5; r++) {
+    const s = E(n, t);
+    if (x(s)) return s;
+  }
+  throw Error("noPrimesFound");
+};
+class u {
+  #t;
+  #n;
+  static name = "Rational";
+  [Symbol.toStringTag] = u.name;
+  /**
+   * fraction (rational) class
+   * @param numerator
+   * @param denominator
+   */
+  constructor(t, e) {
+    e === 0n ? (this.#n = 0n, this.#t = t === 0n ? 0n : t > 0n ? 1n : -1n) : e > 0n ? (this.#t = t, this.#n = e) : (this.#t = -t, this.#n = -e), this.#e();
+  }
+  /**
+   * generates fraction from `number` decimal using continued fraction
+   * @param value decimal
+   * @param denominatorDigits limit of digits of denominator
+   */
+  static fromDecimal(t, e = 5) {
+    if (Number.isNaN(t))
+      return new u(0n, 0n);
+    if (Math.abs(t) === 1 / 0)
+      return new u(t > 0 ? 1n : -1n, 0n);
+    const r = t < 0;
+    r && (t *= -1);
+    const s = BigInt(Math.floor(t)), o = t - Number(s);
+    if (o === 0)
+      return new u(r ? -s : s, 1n);
+    t = 1 / o;
+    let [i, c] = [1n, s], [a, l] = [0n, 1n];
+    for (; `${l}`.length < e + 1; ) {
+      const f = BigInt(Math.floor(t)), h = t - Number(f);
+      if ([i, c] = [c, f * c + i], [a, l] = [l, f * l + a], h === 0)
+        return new u(r ? -c : c, l);
+      t = 1 / h;
+    }
+    return new u(r ? -i : i, a);
+  }
+  /**
+   * reduction
+   */
+  #e() {
+    const { gcd: t } = j(this.#t, this.#n);
+    t !== 0n && (this.#t /= t, this.#n /= t);
+  }
+  /**
+   * returns a fraction multiplied by -1
+   * @returns
+   */
+  minus() {
+    return new u(-this.#t, this.#n);
+  }
+  /**
+   * returns inverse of this fraction
+   * @returns
+   */
+  inverse() {
+    return new u(this.#n, this.#t);
+  }
+  /**
+   * returns `this + right`
+   * @param right
+   * @returns
+   */
+  add(t) {
+    const e = this.#n * t.#n, r = this.#t * t.#n + t.#t * this.#n;
+    return new u(r, e);
+  }
+  /**
+   * returns `this - right`
+   * @param right
+   * @returns
+   */
+  substr(t) {
+    return this.add(t.minus());
+  }
+  /**
+   * returns `this * right`
+   * @param right
+   * @returns
+   */
+  multiply(t) {
+    const e = this.#n * t.#n, r = this.#t * t.#t;
+    return new u(r, e);
+  }
+  /**
+   * returns `this / right`
+   * @param right
+   * @returns
+   */
+  divide(t) {
+    return this.multiply(t.inverse());
+  }
+  /**
+   * returns mediant
+   * @param this `a/b`
+   * @param right `c/d`
+   * @returns `(a+c)/(b+d)`
+   */
+  mediant(t) {
+    const e = this.#n + t.#n, r = this.#t + t.#t;
+    return new u(r, e);
+  }
+  /**
+   * returns `number` type decimal
+   * @returns decimal
+   */
+  toDecimal() {
+    return Number(this.#t) / Number(this.#n);
+  }
+  /**
+   * returns `'numerator/denominator'`
+   * @returns string form
+   */
+  toString() {
+    return this.#t === 0n && this.#n === 0n ? "NaN" : this.#t === 0n ? "0" : this.#n === 0n ? this.#t < 0n ? "-Infinity" : "Infinity" : this.#n === 1n ? `${this.#t}` : `${this.#t}/${this.#n}`;
+  }
+  valueOf() {
+    return this.toDecimal();
+  }
+  toJSON() {
+    return {
+      type: "Rational",
+      value: ["0x" + this.#t.toString(16), "0x" + this.#n.toString(16)]
+    };
+  }
+  /**
+   * makes instance from RationalData
+   * @param data
+   * @returns
+   */
+  static fromData(t) {
+    const e = BigInt(t.value[0]), r = BigInt(t.value[1]);
+    return new u(e, r);
+  }
+  /**
+   * pases string whose form is `'numerator/denominator'`
+   * @param fracStr
+   * @returns
+   */
+  static parse(t) {
+    const r = /^\s*(\d+)\s*\/\s*(\d+)\s*$/.exec(t);
+    if (!r)
+      throw Error("cannot parse");
+    const s = r.at(1), o = r.at(2);
+    if (!s || !o)
+      throw Error("cannot parse");
+    return new u(BigInt(s), BigInt(o));
+  }
+}
+const D = new TextEncoder(), q = new TextDecoder(), lt = (n, t) => {
+  switch (t) {
+    case "utf-8":
+      return D.encode(n);
+    case "base64":
+      return Uint8Array.from(atob(n), (e) => e.charCodeAt(0));
+    case "base64url": {
+      const e = n.length & 3;
+      return e > 0 && (n = n + "=".repeat(4 - e)), n = n.replaceAll("-", "+").replaceAll("_", "/"), Uint8Array.from(atob(n), (r) => r.charCodeAt(0));
+    }
+    case "hex": {
+      n.length & 1 && (n = "0" + n);
+      const r = n.matchAll(/.{2}/g);
+      return Uint8Array.from(r, (s) => Number.parseInt(s[0], 16));
+    }
+    case "oct": {
+      const e = n.length & 7;
+      e && (n = "0".repeat(8 - e) + n);
+      const r = n.matchAll(/.{8}/g), o = Array.from(r, (i) => {
+        const c = i[0];
+        return Number.parseInt(c, 8).toString(16).padStart(6, "0");
+      }).join("").matchAll(/.{2}/g);
+      return Uint8Array.from(
+        o,
+        (i) => Number.parseInt(i[0], 16)
+      );
+    }
+    case "bin": {
+      const e = n.length & 7;
+      e && (n = "0".repeat(8 - e) + n);
+      const r = n.matchAll(/.{8}/g), s = Array.from(r, (o) => Number.parseInt(o[0], 2));
+      return Uint8Array.from(s);
+    }
+    default:
+      throw Error(`Invalid encoding: ${t}`, { cause: t });
+  }
+}, ut = (n, t) => {
+  switch (t) {
+    case "utf-8":
+      return q.decode(n);
+    case "base64": {
+      const e = Array.from(n, (r) => String.fromCharCode(r)).join("");
+      return btoa(e);
+    }
+    case "base64url": {
+      const e = Array.from(n, (s) => String.fromCharCode(s)).join("");
+      return btoa(e).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+    }
+    case "hex":
+      return Array.from(n, (r) => r.toString(16).padStart(2, "0")).join("").replace(/^0+/, "");
+    case "oct": {
+      let e = Array.from(
+        n,
+        (i) => i.toString(16).padStart(2, "0")
+      ).join("");
+      const r = e.length % 6;
+      r && (e = "0".repeat(6 - r) + e);
+      const s = e.matchAll(/.{6}/g);
+      return Array.from(
+        s,
+        (i) => Number.parseInt(i[0], 16).toString(8).padStart(8, "0")
+      ).join("").replace(/^0+/, "");
+    }
+    case "bin":
+      return Array.from(n, (r) => r.toString(2).padStart(8, "0")).join("").replace(/^0+/, "");
+    default:
+      throw Error(`Invalid encoding: ${t}`, { cause: t });
+  }
+}, K = (n) => {
+  const t = n < 0n;
+  t && (n *= -1n);
+  const e = n.toString(2).length, r = n === 1n << BigInt(e - 1) && !(e % 7) && t, s = Math.floor(e / 7) + 1;
+  return r ? s - 1 : s;
+}, ft = (n) => {
+  const t = K(n);
+  n = BigInt.asUintN(t * 7, n);
+  const e = new Uint8Array(t);
+  for (let s = 0; s < t - 1; ++s) {
+    const o = Number(n & 127n) | 128;
+    e[s] = o, n >>= 7n;
+  }
+  const r = Number(n & 127n);
+  return e[t - 1] = r, n >>= 7n, e;
+}, ht = (n) => {
+  const t = n.length;
+  let e = 0n;
+  for (let r = 0; r < t; ++r) {
+    const s = BigInt(n[r] & 127);
+    e += s << BigInt(7 * r);
+  }
+  return BigInt.asIntN(7 * t, e);
+};
+class N {
+  #t;
+  #n;
+  static name = "Queue";
+  [Symbol.toStringTag] = N.name;
+  /**
+   * Queue
+   * @param data
+   */
+  constructor(...t) {
+    this.#t = t, this.#n = [];
+  }
+  /**
+   * enqueue data
+   * @param data
+   * @returns current queue length
+   */
+  enqueue(...t) {
+    return this.#t.push(...t), this.#t.length + this.#n.length;
+  }
+  /**
+   * dequeue data
+   * @returns data in the head
+   */
+  dequeue() {
+    if (this.#n.length === 0)
+      for (; this.#t.length > 0; ) {
+        const t = this.#t.pop();
+        this.#n.push(t);
+      }
+    return this.#n.pop();
+  }
+  toArray() {
+    return this.#n.slice().reverse().concat(this.#t);
+  }
+  toJSON() {
+    return this.toArray();
+  }
+  toString() {
+    return this.toArray().toString();
+  }
+}
+class R extends Error {
+  name;
+  static name = "NamedError";
+  [Symbol.toStringTag] = R.name;
+  constructor(t, e, r) {
+    super(e, { cause: r }), this.name = t;
+  }
+  toJSON() {
+    const t = (() => {
+      const o = this.cause;
+      return typeof o == "string" || typeof o == "number" || typeof o == "boolean" ? o : typeof o == "bigint" ? o.toString() : typeof o == "object" && o !== null ? o instanceof Set || o instanceof Map ? Object.fromEntries(o) : o : void 0;
+    })(), { name: e, message: r, stack: s } = this;
+    return {
+      name: e,
+      message: r,
+      stack: s,
+      cause: t
+    };
+  }
+}
+const S = (n) => {
+  if (n === 0) return 32;
+  let t = 0;
+  for (; n > 0 && !(n & 1); )
+    ++t, n >>>= 1;
+  return t;
+}, B = (n) => {
+  if (n === 0n) return 64n;
+  let t = 0n;
+  for (; n > 0n && !(n & 1n); )
+    ++t, n >>= 1n;
+  return BigInt.asUintN(64, t);
+};
+class A {
+  #t;
+  static name = "FloatRand";
+  [Symbol.toStringTag] = A.name;
+  constructor(t) {
+    this.#t = t;
+  }
+  #n() {
+    const r = (() => {
+      switch (this.#t.bits) {
+        case 32:
+          return this.#t.getU32Rand() >>> 0;
+        case 64: {
+          const f = this.#t.getU64Rand() & 0xffffffffn;
+          return Number(f);
+        }
+      }
+    })(), s = r & 255;
+    let o = 126;
+    if (s === 0) {
+      o -= 8;
+      const f = 1e5;
+      let h = 0;
+      t: for (; ; ) {
+        if (h > f)
+          throw Error("loop exceeded limit");
+        const d = (() => {
+          switch (this.#t.bits) {
+            case 32:
+              return this.#t.getU32Rand() >>> 0;
+            case 64: {
+              const y = BigInt.asUintN(32, this.#t.getU64Rand());
+              return Number(y);
+            }
+          }
+        })();
+        if (d === 0) {
+          if (o -= 32, o < 0) {
+            o = 0;
+            break t;
+          }
+        } else {
+          o -= S(d);
+          break t;
+        }
+        ++h;
+      }
+    } else
+      o -= S(s);
+    const i = r >>> 8 & 8388607;
+    i === 0 && r >>> 31 && ++o;
+    const { buffer: c, byteOffset: a, length: l } = Uint32Array.from([o << 23 | i]);
+    return new Float32Array(c, a, l)[0];
+  }
+  /**
+   * returns a random single-precision floating-point number (float32) in the range of [0.0, 1.0)
+   * @returns
+   */
+  getF32Rand() {
+    for (let e = 0; e < 1e5; ++e) {
+      const r = this.#n();
+      if (r < 1)
+        return r;
+    }
+    throw Error("exceeded loop limit");
+  }
+  #e() {
+    const t = 0n, e = 1023n, r = (() => {
+      switch (this.#t.bits) {
+        case 32: {
+          const f = BigInt(this.#t.getU32Rand() >>> 0), h = BigInt(this.#t.getU32Rand() >>> 0);
+          return f << 32n | h;
+        }
+        case 64:
+          return BigInt.asUintN(64, this.#t.getU64Rand());
+      }
+    })(), s = r & 0x7ffn;
+    let o = e - 1n;
+    if (s === 0n) {
+      o -= 11n;
+      const f = 1e5;
+      let h = 0;
+      t: for (; ; ) {
+        if (h > f)
+          throw Error("loop exceeded limit");
+        const d = (() => {
+          switch (this.#t.bits) {
+            case 32: {
+              const y = BigInt(this.#t.getU32Rand() >>> 0), L = BigInt(this.#t.getU32Rand() >>> 0);
+              return y << 32n | L;
+            }
+            case 64:
+              return BigInt.asUintN(64, this.#t.getU64Rand());
+          }
+        })();
+        if (d === 0n) {
+          if (o -= 64n, o < t) {
+            o = t;
+            break t;
+          }
+        } else {
+          o -= B(d);
+          break t;
+        }
+        ++h;
+      }
+    } else
+      o -= B(s);
+    const i = BigInt.asUintN(52, r >> 11n);
+    i === 0n && r >> 63n && ++o;
+    const { buffer: c, byteOffset: a, length: l } = BigUint64Array.from([o << 52n | i]);
+    return new Float64Array(c, a, l)[0];
+  }
+  /**
+   * returns a random double-precision floating-point number (float64) in the range of [0.0, 1.0)
+   * @returns
+   */
+  getF64Rand() {
+    for (let e = 0; e < 1e5; ++e) {
+      const r = this.#e();
+      if (r < 1)
+        return r;
+    }
+    throw Error("exceeded loop limit");
+  }
+}
+const z = [0x853c49e6748fea9bn, 0xda3e39cb94b95bdbn], J = 0x5851f42d4c957f2dn;
+class M {
+  /**
+   * length = 2, `[state, increment]`
+   */
+  #t;
+  static name = "PCGMinimal";
+  [Symbol.toStringTag] = M.name;
+  bits = 32;
+  /**
+   * @param seeds
+   * `BigUint64Array` with length 2. \
+   * if it is not given, initialized by default value
+   * @example
+   * // the following example is always initialized by the same seeds.
+   * // not recommended
+   * const rng = new PCGMinimal();
+   *
+   * // you should construct with random seeds.
+   * const seed = crypto.getRandomValues(new BigUint64Array(2));
+   * const betterRng = new PCGMinimal(seed);
+   */
+  constructor(t) {
+    t && t.length >= 2 ? (this.#t = new BigUint64Array(2), this.#t[1] = t[1] << 1n | 1n, this.#n(), this.#t[0] += t[0], this.#n()) : this.#t = BigUint64Array.from(z);
+  }
+  /** step inner state */
+  #n() {
+    this.#t[0] = this.#t[0] * J + this.#t[1];
+  }
+  /** 32bit 乱数を返す (内部状態は変わらない) */
+  get #e() {
+    const t = this.#t[0], e = Number(t >> 59n), r = Number(BigInt.asUintN(32, (t ^ t >> 18n) >> 27n));
+    return F(r, e);
+  }
+  /**
+   *
+   * @returns a random 32-bit unsigned integer
+   */
+  getU32Rand() {
+    return this.#n(), this.#e;
+  }
+  /**
+   * @returns a random 32-bit unsigned integer less than `bound`
+   */
+  getBoundedU32Rand(t) {
+    if (t > 4294967296) throw Error("`bound` exceeded limit (2^32)");
+    if (t <= 0)
+      throw Error("'bound' must be positive");
+    const r = 4294967296 % t, s = 1e5;
+    for (let o = 0; o < s; ++o) {
+      const i = this.getU32Rand();
+      if (i >= r)
+        return i % t;
+    }
+    throw Error("exceeded loop limit");
+  }
+  /**
+   *
+   * @param step the number of needed random integers
+   * @param bound upper limit
+   * @returns
+   * the iterator that generates random 32-bit unsigned integers `step` times \
+   * if `bound` is given, random integers are less than `bound`
+   */
+  *genU32Rands(t, e) {
+    if (t <= 0)
+      throw Error("'step' must be positive");
+    for (let r = 0; r < t; r++)
+      yield typeof e == "number" ? this.getBoundedU32Rand(e) : this.getU32Rand();
+  }
+}
+const W = [
+  0xbe562cb412e2260en,
+  0x2e4284137d641affn,
+  0x4e19b36ee933e27en,
+  0x7581cf8c4f4d4f7dn
+];
+class T {
+  bits = 64;
+  #t;
+  static name = "XoshiroMinimal";
+  [Symbol.toStringTag] = T.name;
+  /**
+   * @param seeds
+   * `BigUint64Array` with length 4. \
+   * if it is not given, initialized by default value
+   * @example
+   * // the following example is always initialized by the same seeds.
+   * // not recommended
+   * const rng = new XoshiroMinimal();
+   *
+   * // you should construct with random seeds.
+   * const seed = crypto.getRandomValues(new BigUint64Array(4));
+   * const betterRng = new PCGMinimal(seed);
+   */
+  constructor(t) {
+    t && t.length >= 4 ? (this.#t = new BigUint64Array(4), this.#t[0] = t[0], this.#t[1] = t[1], this.#n(), this.#t[2] += t[2], this.#t[3] += t[3]) : this.#t = BigUint64Array.from(W);
+  }
+  #n() {
+    const t = this.#t[1] << 17n;
+    this.#t[2] ^= this.#t[0], this.#t[3] ^= this.#t[1], this.#t[1] ^= this.#t[2], this.#t[0] ^= this.#t[3], this.#t[2] ^= t, this.#t[3] = I(this.#t[3], 45n);
+  }
+  get value() {
+    return I(this.#t[0] + this.#t[3], 23n) + this.#t[0];
+  }
+  getU64Rand() {
+    const t = this.value;
+    return this.#n(), t;
+  }
+  getU32Rand() {
+    const t = BigInt.asUintN(32, this.getU64Rand());
+    return Number(t);
+  }
+  getBoundedU64Rand(t) {
+    const e = 1n << 64n;
+    if (t > e)
+      throw Error("'bound' exceeded limit");
+    if (t <= 0n)
+      throw Error("'bound' must be positive");
+    const r = e % t, s = 1e5;
+    for (let o = 0; o < s; ++o) {
+      const i = this.getU64Rand();
+      if (i >= r)
+        return i % t;
+    }
+    throw Error("exceeded loop limit");
+  }
+  getBoundedU32Rand(t) {
+    if (t > 4294967296)
+      throw Error("'bound' exceeded limit");
+    if (t <= 0n)
+      throw Error("'bound' must be positive");
+    const r = this.getBoundedU64Rand(BigInt(t));
+    return Number(r);
+  }
+  *genU64Rands(t, e) {
+    if (t <= 0)
+      throw Error("'step' must be positive");
+    for (let r = 0; r < t; ++r)
+      yield e === void 0 ? this.getU64Rand() : this.getBoundedU64Rand(e);
+  }
+  *genU32Rands(t, e) {
+    if (t <= 0)
+      throw Error("'step' must be positive");
+    for (let r = 0; r < t; ++r)
+      yield e === void 0 ? this.getU32Rand() : this.getBoundedU32Rand(e);
+  }
+}
+export {
+  A as FloatRng,
+  R as NamedError,
+  M as PCGMinimal,
+  N as Queue,
+  u as Rational,
+  T as XoshiroMinimal,
+  x as bailliePSW,
+  rt as compress,
+  ht as decodeLEB128,
+  et as decodeRFC3986URIComponent,
+  st as decompress,
+  ft as encodeLEB128,
+  nt as encodeRFC3986URIComponent,
+  j as exEuclidean,
+  it as factorial,
+  lt as fromString,
+  Q as getHash,
+  E as getRandBIByBitLength,
+  _ as getRandBIByRange,
+  at as getRandPrimeByBitLength,
+  ct as getRandPrimeByRange,
+  ot as getRndInt,
+  g as isDeepStrictEqual,
+  tt as isNode,
+  P as isSquare,
+  U as jacobiSymbol,
+  X as lazify,
+  p as modPow,
+  Z as parseCSV,
+  G as promiseWithResolvers,
+  m as residue,
+  F as rot32,
+  I as rot64,
+  Y as sameValueZero,
+  H as sleep,
+  ut as toString
+};