@tktb-tess/util-fns 0.8.6 → 0.9.0

package/dist/bundle.js

@@ -1,4 +1,4 @@
-const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
+const M = new TextEncoder(), z = (n, t) => [n].includes(t), d = (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;
@@ -11,33 +11,33 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
   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;
+      if (!d(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);
+    return !!d(s, o);
   }
   if (n instanceof Map && t instanceof Map) {
     const s = [...n.keys()], o = [...t.keys()];
-    if (!g(s, o)) return !1;
+    if (!d(s, o)) return !1;
     const i = [...n.values()], c = [...t.values()];
-    return !!g(i, c);
+    return !!d(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 f = c.find((d) => d === a);
-      if (f === void 0) return !1;
-      const [h, u] = [s[a], o[f]];
-      if (!g(h, u)) return !1;
+      const u = c.find((p) => p === a);
+      if (u === void 0) return !1;
+      const [f, h] = [s[a], o[u]];
+      if (!d(f, h)) return !1;
     }
     return !0;
   }
   throw Error(`comparing these objects is unavailable: ${n}, ${t}`, {
     cause: [n, t]
   });
-}, z = () => {
+}, J = () => {
   let n, t;
   return {
     promise: new Promise((r, s) => {
@@ -46,9 +46,9 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
     resolve: n,
     reject: t
   };
-}, J = (n) => new Promise((t) => {
+}, W = (n) => new Promise((t) => {
   setTimeout(() => t(), n);
-}), W = (n) => (...t) => () => n(...t), G = (n) => {
+}), Y = (n) => (...t) => () => n(...t), G = (n) => {
   const t = [];
   let e = [], r = "", s = !1;
   for (let o = 0; o < n.length; o++) {
@@ -58,53 +58,53 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
   }
   return e.push(r.trim()), t.push(e), t;
 }, H = async (n, t) => {
-  const e = T.encode(n), r = await crypto.subtle.digest(t, e);
+  const e = M.encode(n), r = await crypto.subtle.digest(t, e);
   return new Uint8Array(r);
-}, Z = () => !!globalThis.process && typeof process.version < "u" && typeof process.versions.node < "u", X = (n) => encodeURIComponent(n).replace(
+}, X = () => !!globalThis.process && typeof process.version < "u" && typeof process.versions.node < "u", Z = (n) => encodeURIComponent(n).replace(
   /[!'()*]/g,
   (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`
-), Y = (n) => {
+), Q = (n) => {
   if (n.includes("+"))
     throw Error("An input string has '+'");
   return decodeURIComponent(n);
-}, Q = async (n, t) => {
+}, tt = async (n, t) => {
   const r = new Blob([n]).stream().pipeThrough(new CompressionStream(t));
   return new Response(r).bytes();
-}, tt = async (n, t) => {
+}, nt = async (n, t) => {
   const r = new Blob([n]).stream().pipeThrough(new DecompressionStream(t));
   return new Response(r).bytes();
-}, nt = (n, t) => Math.floor(Math.random() * (t - n) + n), m = (n, t) => {
+}, et = (n, t) => Math.floor(Math.random() * (t - n) + n), g = (n, t) => {
   t < 0n && (t *= -1n);
   const e = n % t;
   return e < 0n ? e + t : e;
-}, E = (n, t = !1) => {
+}, B = (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);
-}, j = (n, t) => {
+}, L = (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))
+      const c = B(r);
+      if (c >= m(2n, BigInt(r), e))
         return c % e;
     }
     throw Error("Failed to generate a random bigint");
   })();
   return n + s;
-}, p = (n, t, e) => {
+}, m = (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 = g(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;
-}, _ = (n, t) => {
+}, T = (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 };
@@ -112,9 +112,9 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
     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, f = s - a * c;
-    if (f === 0n) break;
-    [e, o] = [o, e - a * o], [r, i] = [i, r - a * i], [s, c] = [c, f];
+    const a = s / c, u = s - a * c;
+    if (u === 0n) break;
+    [e, o] = [o, e - a * o], [r, i] = [i, r - a * i], [s, c] = [c, u];
   }
   return c < 0n && (o *= -1n, i *= -1n, c *= -1n), { x: o, y: i, gcd: c };
 }, w = (n, t) => {
@@ -136,12 +136,12 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
     r *= w(t, i), t = i, e *= r;
   }
   return e;
-}, et = (n) => {
+}, rt = (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 v(n) << t;
-}, rt = (n, t) => BigInt.asUintN(32, n >> (t & 31n) | n << (-t & 31n)), C = (n, t) => (n >>> (t & 31) | n << (-t & 31)) >>> 0, b = (n, t) => {
+}, _ = (n, t) => (n >>> (t & 31) | n << (-t & 31)) >>> 0, b = (n, t) => BigInt.asUintN(64, n >> (t & 63n) | n << (-t & 63n)), I = (n, t) => {
   if (t < 1n || t % 2n === 0n)
     throw Error("`n` is invalid");
   for (; n < 0n; )
@@ -157,7 +157,7 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
     [n, t] = [t, n], n % 4n === 3n && t % 4n === 3n && (e *= -1n), n %= t;
   }
   return t === 1n ? e : 0n;
-}, F = (n) => {
+}, j = (n) => {
   if (n < 0n) return !1;
   if (n === 0n) return !0;
   let t = 1n, e = n;
@@ -166,49 +166,49 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
     r ** 2n < n ? t = r : e = r;
   }
   return n === t ** 2n || n === (t + 1n) ** 2n;
-}, L = (n) => {
+}, C = (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);
+  let i = m(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;
-}, P = (n) => {
-  let t = 5n, e = b(t, n);
+}, F = (n) => {
+  let t = 5n, e = I(t, n);
   for (; e > 0n; ) {
-    if (t = t > 0n ? t + 2n : t - 2n, t *= -1n, t === -15n && F(n))
+    if (t = t > 0n ? t + 2n : t - 2n, t *= -1n, t === -15n && j(n))
       return [0n, 0n];
-    e = b(t, n);
+    e = I(t, n);
   }
   return [t, e];
-}, y = (n, t) => (n & 1n) === 1n ? m(n + t >> 1n, t) : m(n >> 1n, t), V = (n, t, e, r) => {
+}, y = (n, t) => (n & 1n) === 1n ? g(n + t >> 1n, t) : g(n >> 1n, t), P = (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), y(o * o + r * s * s, t)], c === "1" && ([s, o] = [y(e * s + o, t), y(r * s + e * o, t)]);
+    [s, o] = [g(s * o, t), y(o * o + r * s * s, t)], c === "1" && ([s, o] = [y(e * s + o, t), y(r * s + e * o, t)]);
   return [s, o];
-}, O = (n, t, e, r) => {
+}, V = (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] = V(s, n, e, t);
+  const [i, c] = P(s, n, e, t);
   let a = c;
   if (i === 0n) return !0;
-  r = p(r, s, n);
-  for (let f = 0n; f < o; f++) {
+  r = m(r, s, n);
+  for (let u = 0n; u < o; u++) {
     if (a === 0n) return !0;
-    a = m(a * a - 2n * r, n), r = p(r, 2n, n);
+    a = g(a * a - 2n * r, n), r = m(r, 2n, n);
   }
   return !1;
-}, x = (n) => {
+}, E = (n) => {
   if (n <= 1n) return !1;
   if (n % 2n === 0n) return n === 2n;
   const t = [
@@ -242,26 +242,26 @@ const T = new TextEncoder(), K = (n, t) => [n].includes(t), g = (n, t) => {
   for (const o of t)
     if (n % o === 0n)
       return n === o;
-  if (!L(n))
+  if (!C(n))
     return !1;
-  const [e, r] = P(n);
+  const [e, r] = F(n);
   if (r === 0n) return !1;
   const s = (1n - e) / 4n;
-  return O(n, e, 1n, s);
+  return V(n, e, 1n, s);
 }, st = (n, t) => {
   if (t < 2n)
     throw Error("noPrimesFound");
   for (let r = 0; r < 1e5; r++) {
-    const s = j(n, t);
-    if (x(s)) return s;
+    const s = L(n, t);
+    if (E(s)) return s;
   }
   throw Error("noPrimesFound");
 }, ot = (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;
+    const s = B(n, t);
+    if (E(s)) return s;
   }
   throw Error("noPrimesFound");
 };
@@ -294,12 +294,12 @@ class l {
     if (o === 0)
       return new l(r ? -s : s, 1n);
     t = 1 / o;
-    let [i, c] = [1n, s], [a, f] = [0n, 1n];
-    for (; `${f}`.length < e + 1; ) {
-      const h = BigInt(Math.floor(t)), u = t - Number(h);
-      if ([i, c] = [c, h * c + i], [a, f] = [f, h * f + a], u === 0)
-        return new l(r ? -c : c, f);
-      t = 1 / u;
+    let [i, c] = [1n, s], [a, u] = [0n, 1n];
+    for (; `${u}`.length < e + 1; ) {
+      const f = BigInt(Math.floor(t)), h = t - Number(f);
+      if ([i, c] = [c, f * c + i], [a, u] = [u, f * u + a], h === 0)
+        return new l(r ? -c : c, u);
+      t = 1 / h;
     }
     return new l(r ? -i : i, a);
   }
@@ -307,7 +307,7 @@ class l {
    * reduction
    */
   #e() {
-    const { gcd: t } = _(this.#t, this.#n);
+    const { gcd: t } = T(this.#t, this.#n);
     t !== 0n && (this.#t /= t, this.#n /= t);
   }
   /**
@@ -415,7 +415,7 @@ class l {
     return new l(BigInt(s), BigInt(o));
   }
 }
-const $ = new TextEncoder(), k = new TextDecoder(), it = (n, t) => {
+const $ = new TextEncoder(), O = new TextDecoder(), it = (n, t) => {
   switch (t) {
     case "utf-8":
       return $.encode(n);
@@ -454,7 +454,7 @@ const $ = new TextEncoder(), k = new TextDecoder(), it = (n, t) => {
 }, ct = (n, t) => {
   switch (t) {
     case "utf-8":
-      return k.decode(n);
+      return O.decode(n);
     case "base64": {
       const e = Array.from(n, (r) => String.fromCharCode(r)).join("");
       return btoa(e);
@@ -483,12 +483,35 @@ const $ = new TextEncoder(), k = new TextDecoder(), it = (n, t) => {
     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;
+}, at = (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;
+}, ut = (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 A {
+class x {
   #t;
   #n;
   static name = "Queue";
-  [Symbol.toStringTag] = A.name;
+  [Symbol.toStringTag] = x.name;
   /**
    * Queue
    * @param data
@@ -526,10 +549,10 @@ class A {
     return this.toArray().toString();
   }
 }
-class B extends Error {
+class N extends Error {
   name;
   static name = "NamedError";
-  [Symbol.toStringTag] = B.name;
+  [Symbol.toStringTag] = N.name;
   constructor(t, e, r) {
     super(e, { cause: r }), this.name = t;
   }
@@ -546,7 +569,7 @@ class B extends Error {
     };
   }
 }
-const I = (n) => {
+const U = (n) => {
   if (n === 0) return 32;
   let t = 0;
   for (; n > 0 && !(n & 1); )
@@ -559,43 +582,59 @@ const I = (n) => {
     ++t, n >>= 1n;
   return BigInt.asUintN(64, t);
 };
-class U {
+class R {
   #t;
   static name = "FloatRand";
-  [Symbol.toStringTag] = U.name;
+  [Symbol.toStringTag] = R.name;
   constructor(t) {
     this.#t = t;
   }
   #n() {
-    const r = this.#t.getU32Rand() >>> 0, s = r & 255;
+    const r = (() => {
+      switch (this.#t.bits) {
+        case 32:
+          return this.#t.getU32Rand() >>> 0;
+        case 64: {
+          const a = this.#t.getU64Rand() & 0xffffffffn;
+          return Number(a);
+        }
+      }
+    })(), s = r & 255;
     let o = 126;
     if (s === 0) {
       o -= 8;
-      const h = 1e5;
+      const a = 1e5;
       let u = 0;
       t: for (; ; ) {
-        if (u > h)
+        if (u > a)
           throw Error("loop exceeded limit");
-        const d = this.#t.getU32Rand() >>> 0;
-        if (d === 0) {
+        const f = (() => {
+          switch (this.#t.bits) {
+            case 32:
+              return this.#t.getU32Rand() >>> 0;
+            case 64: {
+              const h = BigInt.asUintN(32, this.#t.getU64Rand());
+              return Number(h);
+            }
+          }
+        })();
+        if (f === 0) {
           if (o -= 32, o < 0) {
             o = 0;
             break t;
           }
         } else {
-          o -= I(d);
+          o -= U(f);
           break t;
         }
         ++u;
       }
     } else
-      o -= I(s);
+      o -= U(s);
     const i = r >>> 8 & 8388607;
     i === 0 && r >>> 31 && ++o;
-    const { buffer: c, byteOffset: a, length: f } = Uint32Array.from([
-      o << 23 | i
-    ]);
-    return new Float32Array(c, a, f)[0];
+    const { buffer: c } = Uint32Array.from([o << 23 | i]);
+    return new Float32Array(c)[0];
   }
   /**
    * returns a random single-precision floating-point number (float32) in the range of [0.0, 1.0)
@@ -611,40 +650,50 @@ class U {
   }
   #e() {
     const t = 0n, e = 1023n, r = (() => {
-      const h = BigInt(this.#t.getU32Rand() >>> 0), u = BigInt(this.#t.getU32Rand() >>> 0);
-      return h << 32n | u;
+      switch (this.#t.bits) {
+        case 32: {
+          const a = BigInt(this.#t.getU32Rand() >>> 0), u = BigInt(this.#t.getU32Rand() >>> 0);
+          return a << 32n | u;
+        }
+        case 64:
+          return BigInt.asUintN(64, this.#t.getU64Rand());
+      }
     })(), s = r & 0x7ffn;
     let o = e - 1n;
     if (s === 0n) {
       o -= 11n;
-      const h = 1e5;
+      const a = 1e5;
       let u = 0;
       t: for (; ; ) {
-        if (u > h)
+        if (u > a)
           throw Error("loop exceeded limit");
-        const d = (() => {
-          const R = BigInt(this.#t.getU32Rand() >>> 0), M = BigInt(this.#t.getU32Rand() >>> 0);
-          return R << 32n | M;
+        const f = (() => {
+          switch (this.#t.bits) {
+            case 32: {
+              const h = BigInt(this.#t.getU32Rand() >>> 0), p = BigInt(this.#t.getU32Rand() >>> 0);
+              return h << 32n | p;
+            }
+            case 64:
+              return BigInt.asUintN(64, this.#t.getU64Rand());
+          }
         })();
-        if (d === 0n) {
+        if (f === 0n) {
           if (o -= 64n, o < t) {
             o = t;
             break t;
           }
         } else {
-          o -= S(d);
+          o -= S(f);
           break t;
         }
         ++u;
       }
     } else
       o -= S(s);
-    const i = r >> 11n & 0xfffffffffffffn;
+    const i = BigInt.asUintN(52, r >> 11n);
     i === 0n && r >> 63n && ++o;
-    const { buffer: c, byteOffset: a, length: f } = BigUint64Array.from([
-      o << 52n | i
-    ]);
-    return new Float64Array(c, a, f)[0];
+    const { buffer: c } = BigUint64Array.from([o << 52n | i]);
+    return new Float64Array(c)[0];
   }
   /**
    * returns a random double-precision floating-point number (float64) in the range of [0.0, 1.0)
@@ -660,36 +709,29 @@ class U {
   }
 }
 const D = [0x853c49e6748fea9bn, 0xda3e39cb94b95bdbn], q = 0x5851f42d4c957f2dn;
-class N {
+class A {
   /**
    * length = 2, `[state, increment]`
    */
   #t;
   static name = "PCGMinimal";
-  [Symbol.toStringTag] = N.name;
-  /**
-   * returns seed for constructing `PCGMinimal` instance
-   * @returns random seed `BigUint64Array` with length 2
-   * @example
-   * const rng = new PCGMinimal(PCGMinimal.getSeed())
-   */
-  static getSeed() {
-    return crypto.getRandomValues(new BigUint64Array(2));
-  }
+  [Symbol.toStringTag] = A.name;
+  bits = 32;
   /**
    * @param seeds
-   * `BigUintArray` with length 2. \
+   * `BigUint64Array` with length 2. \
    * if it is not given, initialized by default value
    * @example
    * // the following example is always initialized by the same seeds.
-   * // it's not recommended
-   * const weakRng = new PCGMinimal();
+   * // not recommended
+   * const rng = new PCGMinimal();
    *
-   * // you should construct with random seeds generated by `PCGMinimal.getSeed()`.
-   * const betterRng = new PCGMinimal(PCGMinimal.getSeed());
+   * // 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(D);
+    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(D);
   }
   /** step inner state */
   #n() {
@@ -698,7 +740,7 @@ class N {
   /** 32bit 乱数を返す (内部状態は変わらない) */
   get #e() {
     const t = this.#t[0], e = Number(t >> 59n), r = Number(BigInt.asUintN(32, (t ^ t >> 18n) >> 27n));
-    return C(r, e);
+    return _(r, e);
   }
   /**
    *
@@ -712,11 +754,15 @@ class N {
    */
   getBoundedU32Rand(t) {
     if (t > 4294967296) throw Error("`bound` exceeded limit (2^32)");
-    const r = 4294967296 % t;
-    for (; ; ) {
-      const s = this.getU32Rand();
-      if (s >= r) return s % t;
+    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");
   }
   /**
    *
@@ -727,42 +773,122 @@ class N {
    * 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 K = [
+  0xbe562cb412e2260en,
+  0x2e4284137d641affn,
+  0x4e19b36ee933e27en,
+  0x7581cf8c4f4d4f7dn
+];
+class lt {
+  bits = 64;
+  #t;
+  /**
+   * @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(K);
+  }
+  #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] = b(this.#t[3], 45n);
+  }
+  get value() {
+    return b(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 {
-  U as FloatRand,
-  B as NamedError,
-  N as PCGMinimal,
-  A as Queue,
+  R as FloatRand,
+  N as NamedError,
+  A as PCGMinimal,
+  x as Queue,
   l as Rational,
-  x as bailliePSW,
-  Q as compress,
-  Y as decodeRFC3986URIComponent,
-  tt as decompress,
-  X as encodeRFC3986URIComponent,
-  _ as exEuclidean,
-  et as factorial,
+  lt as XoshiroMinimal,
+  E as bailliePSW,
+  tt as compress,
+  ut as decodeLEB128,
+  Q as decodeRFC3986URIComponent,
+  nt as decompress,
+  at as encodeLEB128,
+  Z as encodeRFC3986URIComponent,
+  T as exEuclidean,
+  rt as factorial,
   it as fromString,
   H as getHash,
-  E as getRandBIByBitLength,
-  j as getRandBIByRange,
+  B as getRandBIByBitLength,
+  L as getRandBIByRange,
   ot as getRandPrimeByBitLength,
   st as getRandPrimeByRange,
-  nt as getRndInt,
-  g as isDeepStrictEqual,
-  Z as isNode,
-  F as isSquare,
-  b as jacobiSymbol,
-  W as lazify,
-  p as modPow,
+  et as getRndInt,
+  d as isDeepStrictEqual,
+  X as isNode,
+  j as isSquare,
+  I as jacobiSymbol,
+  Y as lazify,
+  m as modPow,
   G as parseCSV,
-  z as promiseWithResolvers,
-  m as residue,
-  C as rot32,
-  rt as rot32BI,
-  K as sameValueZero,
-  J as sleep,
+  J as promiseWithResolvers,
+  g as residue,
+  _ as rot32,
+  b as rot64,
+  z as sameValueZero,
+  W as sleep,
   ct as toString
 };

package/dist/main.d.ts

@@ -7,3 +7,4 @@ export * from './queue';
 export * from './named-error';
 export * from './random';
 export * from './pcg-minimal';
+export * from './xoshiro-minimal';

package/dist/math.d.ts

@@ -56,23 +56,23 @@ export declare const exEuclidean: (a: bigint, b: bigint) => {
  */
 export declare const factorial: (n: bigint) => bigint;
 /**
- * 32-bit rotate (bigint)
- * @param value 値
- * @param rot 回転数
+ * 32-bit rorate (number)
+ * @param value
+ * @param rot
  * @returns
  */
-export declare const rot32BI: (value: bigint, rot: bigint) => bigint;
+export declare const rot32: (value: number, rot: number) => number;
 /**
- * 32-bit rorate (number)
- * @param value 値
- * @param rot 回転数
+ * 64-bit rorate (bigint)
+ * @param value
+ * @param rot
  * @returns
  */
-export declare const rot32: (value: number, rot: number) => number;
+export declare const rot64: (value: bigint, rot: bigint) => bigint;
 /**
  * Jacobi symbol `(a/n)`
- * @param a 正の整数
- * @param n 正の奇数
+ * @param a positive integer
+ * @param n positive odd integer
  */
 export declare const jacobiSymbol: (a: bigint, n: bigint) => bigint;
 /**

package/dist/pcg-minimal.d.ts

@@ -1,29 +1,26 @@
-import { RandomGenerator } from './random';
+import { RandomGenerator32 } from './random';
 /**
- * PCG-XSH-RR (Permuted congruential generator)
+ * PCG-XSH-RR (Permuted congruential generator) \
+ * reference: https://github.com/imneme/pcg-c-basic/blob/bc39cd76ac3d541e618606bcc6e1e5ba5e5e6aa3/pcg_basic.c \
+ * by Melissa O'Neill
  */
-export declare class PCGMinimal implements RandomGenerator {
+export declare class PCGMinimal implements RandomGenerator32 {
     #private;
     static readonly name = "PCGMinimal";
     readonly [Symbol.toStringTag] = "PCGMinimal";
-    /**
-     * returns seed for constructing `PCGMinimal` instance
-     * @returns random seed `BigUint64Array` with length 2
-     * @example
-     * const rng = new PCGMinimal(PCGMinimal.getSeed())
-     */
-    static getSeed(): BigUint64Array<ArrayBuffer>;
+    readonly bits = 32;
     /**
      * @param seeds
-     * `BigUintArray` with length 2. \
+     * `BigUint64Array` with length 2. \
      * if it is not given, initialized by default value
      * @example
      * // the following example is always initialized by the same seeds.
-     * // it's not recommended
-     * const weakRng = new PCGMinimal();
+     * // not recommended
+     * const rng = new PCGMinimal();
      *
-     * // you should construct with random seeds generated by `PCGMinimal.getSeed()`.
-     * const betterRng = new PCGMinimal(PCGMinimal.getSeed());
+     * // you should construct with random seeds.
+     * const seed = crypto.getRandomValues(new BigUint64Array(2));
+     * const betterRng = new PCGMinimal(seed);
      */
     constructor(seeds?: BigUint64Array<ArrayBuffer>);
     /**

package/dist/random.d.ts

@@ -1,13 +1,16 @@
-export interface RandomGenerator {
+export interface RandomGenerator32 {
+    readonly bits: 32;
     getU32Rand: () => number;
-    getBoundedU32Rand: (bound: number) => number;
-    genU32Rands: (step: number, bound?: number) => Generator<number, void, unknown>;
 }
-export declare class FloatRand {
+export interface RandomGenerator64 {
+    readonly bits: 64;
+    getU64Rand: () => bigint;
+}
+export declare class FloatRand<TRng extends RandomGenerator32 | RandomGenerator64> {
     #private;
     static readonly name = "FloatRand";
     readonly [Symbol.toStringTag] = "FloatRand";
-    constructor(rng: RandomGenerator);
+    constructor(rng: TRng);
     /**
      * returns a random single-precision floating-point number (float32) in the range of [0.0, 1.0)
      * @returns

package/dist/u8arr-ext.d.ts

@@ -1,3 +1,5 @@
 export type Encoding = 'utf-8' | 'base64' | 'base64url' | 'hex' | 'oct' | 'bin';
 export declare const fromString: (str: string, encoding: Encoding) => Uint8Array<ArrayBuffer>;
 export declare const toString: (u8Arr: Uint8Array, encoding: Encoding) => string;
+export declare const encodeLEB128: (bigint: bigint) => Uint8Array<ArrayBuffer>;
+export declare const decodeLEB128: (leb128: Uint8Array<ArrayBuffer>) => bigint;

package/dist/util.d.ts

@@ -63,5 +63,5 @@ export declare const encodeRFC3986URIComponent: (URIComponent: string | number |
  * @returns
  */
 export declare const decodeRFC3986URIComponent: (encodedURIComponent: string) => string;
-export declare const compress: (bin: Uint8Array<ArrayBuffer>, format: CompressionFormat) => Promise<Uint8Array<ArrayBuffer>>;
-export declare const decompress: (comp: Uint8Array<ArrayBuffer>, format: CompressionFormat) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const compress: (raw: Uint8Array<ArrayBuffer>, format: CompressionFormat) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const decompress: (compressed: Uint8Array<ArrayBuffer>, format: CompressionFormat) => Promise<Uint8Array<ArrayBuffer>>;

package/dist/xoshiro-minimal.d.ts

@@ -0,0 +1,31 @@
+import { RandomGenerator64 } from './random';
+/**
+ * Xoshiro256++ \
+ * reference: https://prng.di.unimi.it/xoshiro256plusplus.c \
+ * by David Blackman and Sebastiano Vigna
+ */
+export declare class XoshiroMinimal implements RandomGenerator64 {
+    #private;
+    readonly bits = 64;
+    /**
+     * @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(seed?: BigUint64Array<ArrayBuffer>);
+    get value(): bigint;
+    getU64Rand(): bigint;
+    getU32Rand(): number;
+    getBoundedU64Rand(bound: bigint): bigint;
+    getBoundedU32Rand(bound: number): number;
+    genU64Rands(step: number, bound?: bigint): Generator<bigint, void, unknown>;
+    genU32Rands(step: number, bound?: number): Generator<number, void, unknown>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tktb-tess/util-fns",
-  "version": "0.8.6",
+  "version": "0.9.0",
   "description": "Utility functions for personal use",
   "files": [
     "dist"