@ppabari/strio 1.0.2

package/dist/index.cjs

@@ -0,0 +1,1913 @@
+'use strict';
+
+// src/core.ts
+function getRandomByte() {
+  const buf = new Uint8Array(1);
+  crypto.getRandomValues(buf);
+  return buf[0];
+}
+function getRandomChar(charset) {
+  const len = charset.length;
+  const maxValid = 256 - 256 % len;
+  let byte;
+  do {
+    byte = getRandomByte();
+  } while (byte >= maxValid);
+  return charset[byte % len];
+}
+function getRandomChars(charset, count) {
+  const len = charset.length;
+  const maxValid = 256 - 256 % len;
+  const result = [];
+  const bufSize = Math.ceil(count * 1.4) + 32;
+  const buf = new Uint8Array(bufSize);
+  while (result.length < count) {
+    crypto.getRandomValues(buf);
+    for (let i = 0; i < buf.length && result.length < count; i++) {
+      const byte = buf[i];
+      if (byte < maxValid) {
+        result.push(charset[byte % len]);
+      }
+    }
+  }
+  return result;
+}
+
+// src/seeded.ts
+function rotl32(x, k) {
+  return (x << k | x >>> 32 - k) >>> 0;
+}
+function seedState(seed) {
+  let a = 2654435769 >>> 0;
+  let b = 1818371886 >>> 0;
+  for (let i = 0; i < seed.length; i++) {
+    const ch = seed.charCodeAt(i);
+    a = Math.imul(a ^ ch, 2654435769) + 1388355149 >>> 0;
+    b = Math.imul(b ^ ch, 2246822507) + 3266489909 >>> 0;
+  }
+  function sm32(v) {
+    v = Math.imul(v ^ v >>> 16, 73244475) + 461845907 >>> 0;
+    v = Math.imul(v ^ v >>> 16, 73244475) + 3864292196 >>> 0;
+    return (v ^ v >>> 16) >>> 0;
+  }
+  return [
+    sm32(a),
+    sm32(b),
+    sm32(a ^ 3735928559),
+    sm32(b ^ 3131961357)
+  ];
+}
+function nextUint32(s) {
+  const result = Math.imul(rotl32(Math.imul(s[1], 5) >>> 0, 7), 9) >>> 0;
+  const t = s[1] << 9 >>> 0;
+  s[2] = (s[2] ^ s[0]) >>> 0;
+  s[3] = (s[3] ^ s[1]) >>> 0;
+  s[1] = (s[1] ^ s[2]) >>> 0;
+  s[0] = (s[0] ^ s[3]) >>> 0;
+  s[2] = (s[2] ^ t) >>> 0;
+  s[3] = rotl32(s[3], 11);
+  return result;
+}
+function seededChar(charset, state) {
+  const len = charset.length;
+  const maxValid = Math.floor(4294967296 / len) * len;
+  let n;
+  do {
+    n = nextUint32(state);
+  } while (n >= maxValid);
+  return charset[n % len];
+}
+function generateSeeded({ seed, charset, length }) {
+  const state = seedState(seed);
+  const chars = [];
+  for (let i = 0; i < length; i++) {
+    chars.push(seededChar(charset, state));
+  }
+  return chars.join("");
+}
+
+// src/charset-aliases.ts
+var CHARSET_ALIASES = {
+  /**
+   * Base16 — hex digits, lowercase.
+   * Use for: hash representations, color codes, compact binary encoding.
+   */
+  base16: "0123456789abcdef",
+  /** Base16 uppercase variant */
+  base16upper: "0123456789ABCDEF",
+  /**
+   * Base32 — RFC 4648. Uppercase alpha + digits, no padding chars.
+   * Use for: case-insensitive tokens, OTP secrets (Google Authenticator compatible).
+   */
+  base32: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  /**
+   * Base32 hex — RFC 4648 §7. Sortable alternative to standard base32.
+   */
+  base32hex: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  /**
+   * Base36 — digits + lowercase alpha.
+   * Use for: short URLs, case-insensitive IDs, number system conversions.
+   */
+  base36: "0123456789abcdefghijklmnopqrstuvwxyz",
+  /**
+   * Base58 — Bitcoin alphabet. No 0/O/I/l to avoid visual ambiguity.
+   * Use for: Bitcoin addresses, IPFS CIDs, human-readable tokens.
+   */
+  base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+  /**
+   * Base62 — digits + lowercase + uppercase. Max density for alphanumeric.
+   * Use for: URL shorteners, compact IDs, high-entropy tokens.
+   */
+  base62: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  /**
+   * Base64 URL-safe — RFC 4648 §5. No +/= padding; URL and filename safe.
+   * Use for: JWT components, URL tokens, file names.
+   */
+  base64url: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_",
+  /**
+   * Alphanumeric — same as base62. Alias for clarity.
+   */
+  alphanumeric: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  /**
+   * Alpha — letters only, mixed case.
+   */
+  alpha: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  /**
+   * Numeric — digits only.
+   */
+  numeric: "0123456789",
+  /**
+   * Hex — alias for base16 lowercase.
+   */
+  hex: "0123456789abcdef",
+  /**
+   * Crockford Base32 — human-friendly, case-insensitive, excludes I/L/O/U.
+   * Use for: serial numbers, redemption codes, user-facing IDs.
+   */
+  crockford32: "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+};
+function resolveCharsetAlias(value) {
+  return CHARSET_ALIASES[value] ?? value;
+}
+
+// src/charsets.ts
+var CHARSETS = {
+  numeric: "0123456789",
+  lowercase: "abcdefghijklmnopqrstuvwxyz",
+  uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  symbols: "!@#$%^&*()_+[]{}<>?",
+  alphanumeric: "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  // Ambiguous characters that are easy to confuse when reading/transcribing
+  ambiguous: "0Ol1I"
+};
+function dedup(str) {
+  return [...new Set(str)].join("");
+}
+function buildCharset(options) {
+  let pool;
+  if (options.charset !== void 0) {
+    pool = dedup(resolveCharsetAlias(options.charset));
+    if (pool.length < 2) {
+      throw new Error(
+        "Custom charset must contain at least 2 unique characters."
+      );
+    }
+    return pool;
+  }
+  const {
+    numeric = true,
+    lowercase = true,
+    uppercase = true,
+    symbols = false
+  } = options;
+  pool = "";
+  if (numeric) pool += CHARSETS.numeric;
+  if (lowercase) pool += CHARSETS.lowercase;
+  if (uppercase) pool += CHARSETS.uppercase;
+  if (symbols) pool += CHARSETS.symbols;
+  if (!pool) {
+    throw new Error(
+      "At least one character type must be enabled (numeric, lowercase, uppercase, or symbols)."
+    );
+  }
+  if (options.readable) {
+    for (const ch of CHARSETS.ambiguous) {
+      pool = pool.split(ch).join("");
+    }
+  }
+  if (options.exclude) {
+    const excludeChars = typeof options.exclude === "string" ? options.exclude : options.exclude.join("");
+    for (const ch of excludeChars) {
+      pool = pool.split(ch).join("");
+    }
+  }
+  pool = dedup(pool);
+  if (pool.length < 2) {
+    throw new Error(
+      "After applying exclusions, the character pool has fewer than 2 unique characters. Loosen your exclude/readable settings or enable more character types."
+    );
+  }
+  return pool;
+}
+function alphabetSubset(fullPool) {
+  return [...fullPool].filter((ch) => /[a-zA-Z]/.test(ch)).join("");
+}
+function numericSubset(fullPool) {
+  return [...fullPool].filter((ch) => /[0-9]/.test(ch)).join("");
+}
+
+// src/generator.ts
+function expandPattern(pattern, fullCharset) {
+  const upper = [...fullCharset].filter((c) => /[A-Z]/.test(c)).join("") || CHARSETS.uppercase;
+  const lower = [...fullCharset].filter((c) => /[a-z]/.test(c)).join("") || CHARSETS.lowercase;
+  const alphanum = [...fullCharset].filter((c) => /[a-zA-Z0-9]/.test(c)).join("") || CHARSETS.alphanumeric;
+  const result = [];
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "\\" && i + 1 < pattern.length) {
+      result.push(pattern[i + 1]);
+      i += 2;
+      continue;
+    }
+    switch (ch) {
+      case "#":
+        result.push(getRandomChar(CHARSETS.numeric));
+        break;
+      case "A":
+        result.push(getRandomChar(upper));
+        break;
+      case "a":
+        result.push(getRandomChar(lower));
+        break;
+      case "*":
+        result.push(getRandomChar(fullCharset));
+        break;
+      case "?":
+        result.push(getRandomChar(alphanum));
+        break;
+      default:
+        result.push(ch);
+    }
+    i++;
+  }
+  return result.join("");
+}
+function generateOne(options) {
+  const {
+    length = 16,
+    prefix = "",
+    suffix = "",
+    startWith = "any",
+    pattern,
+    seed,
+    ...charsetOptions
+  } = options;
+  const charset = buildCharset(charsetOptions);
+  if (seed !== void 0) {
+    if (pattern !== void 0) {
+      const patternLength = [...pattern].filter((_, i) => {
+        return true;
+      }).length;
+      const seededStr2 = generateSeeded({ seed, charset, length: patternLength });
+      return `${prefix}${seededStr2}${suffix}`;
+    }
+    const randomLength2 = length - prefix.length - suffix.length;
+    if (randomLength2 <= 0) return `${prefix}${suffix}`;
+    const seededStr = generateSeeded({ seed, charset, length: randomLength2 });
+    return `${prefix}${seededStr}${suffix}`;
+  }
+  if (pattern !== void 0) {
+    const expanded = expandPattern(pattern, charset);
+    return `${prefix}${expanded}${suffix}`;
+  }
+  const randomLength = length - prefix.length - suffix.length;
+  if (randomLength < 0) {
+    throw new Error(
+      `prefix ('${prefix}') + suffix ('${suffix}') is longer than the total length (${length}). Increase length or shorten the affixes.`
+    );
+  }
+  if (randomLength === 0) {
+    return `${prefix}${suffix}`;
+  }
+  let firstCharset;
+  switch (startWith) {
+    case "alphabet": {
+      const alpha = alphabetSubset(charset);
+      if (!alpha) {
+        throw new Error(
+          "startWith: 'alphabet' requires at least one of lowercase or uppercase to be enabled."
+        );
+      }
+      firstCharset = alpha;
+      break;
+    }
+    case "numeric": {
+      const num = numericSubset(charset);
+      if (!num) {
+        throw new Error(
+          "startWith: 'numeric' requires numeric to be enabled."
+        );
+      }
+      firstCharset = num;
+      break;
+    }
+    default:
+      firstCharset = charset;
+  }
+  const firstChar = getRandomChar(firstCharset);
+  if (randomLength === 1) {
+    return `${prefix}${firstChar}${suffix}`;
+  }
+  const rest = getRandomChars(charset, randomLength - 1).join("");
+  return `${prefix}${firstChar}${rest}${suffix}`;
+}
+function generateBatch(options, count) {
+  if (count <= 0) {
+    throw new Error("count must be a positive integer.");
+  }
+  if (!Number.isInteger(count)) {
+    throw new Error("count must be an integer.");
+  }
+  const results = /* @__PURE__ */ new Set();
+  let attempts = 0;
+  const maxAttempts = count * 10 + 1e3;
+  while (results.size < count) {
+    if (++attempts > maxAttempts) {
+      throw new Error(
+        `Could not generate ${count} unique strings after ${maxAttempts} attempts. The charset and length combination may not support this many unique values.`
+      );
+    }
+    results.add(generateOne(options));
+  }
+  return [...results];
+}
+
+// src/short-id.ts
+function computeChecksum(payload, charset) {
+  const n = charset.length;
+  let sum = 0;
+  for (let i = 0; i < payload.length; i++) {
+    const idx = charset.indexOf(payload[i]);
+    if (idx === -1) return charset[0];
+    const weight = i % 2 === 0 ? 1 : 2;
+    sum += idx * weight;
+  }
+  return charset[sum % n];
+}
+function generateId(options = {}) {
+  const {
+    prefix,
+    separator = "_",
+    randomLength = 12,
+    charset: rawCharset = "base58",
+    checksum = true
+  } = options;
+  const resolvedCharset = resolveCharsetAlias(rawCharset);
+  const charset = buildCharset({ charset: resolvedCharset });
+  if (randomLength < 4) throw new Error("randomLength must be at least 4.");
+  const randomPart = getRandomChars(charset, randomLength).join("");
+  const checksumChar = checksum ? computeChecksum(randomPart, charset) : "";
+  const randomSection = randomPart + checksumChar;
+  if (prefix) {
+    return `${prefix}${separator}${randomSection}`;
+  }
+  return randomSection;
+}
+function validateId(id, options = {}) {
+  const {
+    prefix,
+    separator = "_",
+    charset: rawCharset = "base58",
+    checksum = true
+  } = options;
+  const errors = [];
+  const resolvedCharset = resolveCharsetAlias(rawCharset);
+  let payload = id;
+  if (prefix) {
+    const expectedStart = `${prefix}${separator}`;
+    if (!id.startsWith(expectedStart)) {
+      errors.push(`Expected prefix '${prefix}${separator}', got '${id.slice(0, expectedStart.length)}'.`);
+      return { valid: false, errors };
+    }
+    payload = id.slice(expectedStart.length);
+  }
+  const charsetSet = new Set(resolvedCharset);
+  const badChars = [...new Set(payload)].filter((c) => !charsetSet.has(c));
+  if (badChars.length > 0) {
+    errors.push(`Contains characters outside the expected charset: ${badChars.map((c) => JSON.stringify(c)).join(", ")}.`);
+  }
+  if (checksum && payload.length >= 2 && errors.length === 0) {
+    const randomPart = payload.slice(0, -1);
+    const providedChecksum = payload.slice(-1);
+    const expectedChecksum = computeChecksum(randomPart, resolvedCharset);
+    if (providedChecksum !== expectedChecksum) {
+      errors.push("Checksum mismatch \u2014 ID may be corrupted or mistyped.");
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/expiring-token.ts
+var B62 = CHARSET_ALIASES["base62"];
+var B62_LEN = B62.length;
+var EXPIRY_CHARS = 8;
+function encodeBase62(n, width) {
+  const digits = [];
+  let v = Math.floor(n);
+  for (let i = 0; i < width; i++) {
+    digits.unshift(B62[v % B62_LEN]);
+    v = Math.floor(v / B62_LEN);
+  }
+  return digits.join("");
+}
+function decodeBase62(s) {
+  let v = 0;
+  for (const ch of s) {
+    const idx = B62.indexOf(ch);
+    if (idx === -1) return -1;
+    v = v * B62_LEN + idx;
+  }
+  return v;
+}
+function generateExpiringToken(options = {}) {
+  const { ttlSeconds = 900, payloadLength = 24 } = options;
+  if (ttlSeconds <= 0) throw new Error("ttlSeconds must be a positive number.");
+  if (payloadLength < 8) throw new Error("payloadLength must be at least 8.");
+  const expiresAt = new Date(Date.now() + ttlSeconds * 1e3);
+  const expiryEpoch = Math.floor(expiresAt.getTime() / 1e3);
+  const expiryPart = encodeBase62(expiryEpoch, EXPIRY_CHARS);
+  const payload = generateOne({
+    length: payloadLength,
+    charset: B62
+  });
+  const token = expiryPart + payload;
+  return {
+    token,
+    expiresAt,
+    length: token.length
+  };
+}
+function verifyToken(token) {
+  if (typeof token !== "string" || token.length < EXPIRY_CHARS + 8) {
+    return { valid: false, parsed: false, expired: false, expiresAt: null, secondsRemaining: null };
+  }
+  const expiryStr = token.slice(0, EXPIRY_CHARS);
+  const expiryEpoch = decodeBase62(expiryStr);
+  if (expiryEpoch === -1) {
+    return { valid: false, parsed: false, expired: false, expiresAt: null, secondsRemaining: null };
+  }
+  const expiresAt = new Date(expiryEpoch * 1e3);
+  const nowSeconds = Date.now() / 1e3;
+  const secondsRemaining = Math.round(expiryEpoch - nowSeconds);
+  const expired = secondsRemaining <= 0;
+  return {
+    valid: !expired,
+    parsed: true,
+    expired,
+    expiresAt,
+    secondsRemaining
+  };
+}
+
+// src/stream.ts
+async function* randomStringStream(options = {}) {
+  generateOne(options);
+  while (true) {
+    yield generateOne(options);
+  }
+}
+async function* uniqueRandomStringStream(options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  generateOne(options);
+  while (true) {
+    const candidate = generateOne(options);
+    if (!seen.has(candidate)) {
+      seen.add(candidate);
+      yield candidate;
+    }
+  }
+}
+async function take(iterable, n) {
+  if (n <= 0) return [];
+  if (!Number.isInteger(n)) throw new Error("n must be a positive integer.");
+  const results = [];
+  for await (const value of iterable) {
+    results.push(value);
+    if (results.length >= n) break;
+  }
+  return results;
+}
+async function takeWhere(iterable, n, predicate) {
+  if (n <= 0) return [];
+  const results = [];
+  for await (const value of iterable) {
+    if (predicate(value)) {
+      results.push(value);
+      if (results.length >= n) break;
+    }
+  }
+  return results;
+}
+
+// src/passphrase.ts
+var WORD_LIST = [
+  "able",
+  "acid",
+  "aged",
+  "also",
+  "area",
+  "army",
+  "away",
+  "back",
+  "ball",
+  "band",
+  "bank",
+  "base",
+  "bath",
+  "bear",
+  "beat",
+  "been",
+  "bell",
+  "best",
+  "bird",
+  "bite",
+  "blow",
+  "blue",
+  "boat",
+  "body",
+  "bomb",
+  "bond",
+  "bone",
+  "book",
+  "bore",
+  "born",
+  "both",
+  "bowl",
+  "burn",
+  "busy",
+  "call",
+  "calm",
+  "camp",
+  "card",
+  "care",
+  "cart",
+  "case",
+  "cash",
+  "cast",
+  "cave",
+  "cell",
+  "chat",
+  "chip",
+  "city",
+  "clam",
+  "clap",
+  "clay",
+  "clip",
+  "club",
+  "clue",
+  "coal",
+  "coat",
+  "code",
+  "coil",
+  "cold",
+  "come",
+  "cook",
+  "cool",
+  "copy",
+  "core",
+  "cork",
+  "corn",
+  "cost",
+  "cozy",
+  "crab",
+  "crew",
+  "crop",
+  "crow",
+  "curb",
+  "cure",
+  "dark",
+  "dart",
+  "data",
+  "date",
+  "dawn",
+  "deal",
+  "dear",
+  "deck",
+  "deed",
+  "deep",
+  "deft",
+  "dent",
+  "desk",
+  "dial",
+  "dice",
+  "diet",
+  "dime",
+  "dine",
+  "dirt",
+  "dish",
+  "disk",
+  "dock",
+  "dome",
+  "door",
+  "dose",
+  "dove",
+  "down",
+  "draw",
+  "drew",
+  "drip",
+  "drop",
+  "drum",
+  "dual",
+  "dune",
+  "dusk",
+  "dust",
+  "each",
+  "earl",
+  "earn",
+  "ease",
+  "east",
+  "edge",
+  "else",
+  "emit",
+  "envy",
+  "epic",
+  "even",
+  "exam",
+  "exit",
+  "expo",
+  "face",
+  "fact",
+  "fail",
+  "fair",
+  "fall",
+  "fame",
+  "farm",
+  "fast",
+  "fate",
+  "fawn",
+  "fear",
+  "feat",
+  "feed",
+  "feel",
+  "feet",
+  "fell",
+  "felt",
+  "fern",
+  "fest",
+  "film",
+  "find",
+  "fine",
+  "fire",
+  "firm",
+  "fish",
+  "fist",
+  "flag",
+  "flat",
+  "flaw",
+  "flew",
+  "flip",
+  "flow",
+  "foam",
+  "fold",
+  "folk",
+  "fond",
+  "font",
+  "food",
+  "fool",
+  "foot",
+  "ford",
+  "fork",
+  "form",
+  "fort",
+  "foul",
+  "four",
+  "free",
+  "frog",
+  "from",
+  "fuel",
+  "full",
+  "fund",
+  "fuse",
+  "gain",
+  "gale",
+  "game",
+  "gang",
+  "gate",
+  "gave",
+  "gaze",
+  "gear",
+  "gift",
+  "give",
+  "glad",
+  "glow",
+  "glue",
+  "goal",
+  "goat",
+  "gold",
+  "golf",
+  "gone",
+  "good",
+  "grab",
+  "gray",
+  "grew",
+  "grid",
+  "grin",
+  "grip",
+  "grow",
+  "gulf",
+  "gust",
+  "half",
+  "hall",
+  "halt",
+  "hand",
+  "hang",
+  "hard",
+  "hare",
+  "harm",
+  "harp",
+  "hash",
+  "haul",
+  "hawk",
+  "head",
+  "heal",
+  "heap",
+  "heat",
+  "heel",
+  "held",
+  "helm",
+  "help",
+  "herb",
+  "herd",
+  "hero",
+  "hide",
+  "high",
+  "hike",
+  "hill",
+  "hint",
+  "hire",
+  "hold",
+  "hole",
+  "home",
+  "hood",
+  "hook",
+  "hope",
+  "horn",
+  "hose",
+  "host",
+  "hour",
+  "huge",
+  "hulk",
+  "hull",
+  "hunt",
+  "hymn",
+  "idea",
+  "idle",
+  "inch",
+  "into",
+  "iron",
+  "isle",
+  "item",
+  "jade",
+  "jail",
+  "jest",
+  "join",
+  "joke",
+  "jolt",
+  "jump",
+  "just",
+  "keen",
+  "keep",
+  "kick",
+  "kind",
+  "king",
+  "knee",
+  "knew",
+  "knot",
+  "know",
+  "lace",
+  "lame",
+  "lamp",
+  "land",
+  "lane",
+  "lark",
+  "lash",
+  "last",
+  "late",
+  "lawn",
+  "lead",
+  "leaf",
+  "lean",
+  "leap",
+  "left",
+  "lens",
+  "lift",
+  "like",
+  "limb",
+  "lime",
+  "link",
+  "lion",
+  "list",
+  "live",
+  "load",
+  "loan",
+  "lock",
+  "loft",
+  "long",
+  "look",
+  "loop",
+  "lore",
+  "lose",
+  "lost",
+  "loud",
+  "love",
+  "luck",
+  "lure",
+  "lush",
+  "made",
+  "mail",
+  "main",
+  "make",
+  "mall",
+  "mane",
+  "many",
+  "mark",
+  "mass",
+  "mast",
+  "math",
+  "maze",
+  "mead",
+  "meal",
+  "mean",
+  "meet",
+  "melt",
+  "memo",
+  "menu",
+  "mesh",
+  "mild",
+  "mile",
+  "mill",
+  "mime",
+  "mind",
+  "mine",
+  "mint",
+  "miss",
+  "mist",
+  "mode",
+  "mold",
+  "mole",
+  "mood",
+  "moon",
+  "more",
+  "most",
+  "move",
+  "much",
+  "mule",
+  "myth",
+  "nail",
+  "name",
+  "neck",
+  "need",
+  "nest",
+  "next",
+  "nine",
+  "node",
+  "noel",
+  "norm",
+  "nose",
+  "note",
+  "noun",
+  "oath",
+  "once",
+  "only",
+  "open",
+  "oven",
+  "over",
+  "pack",
+  "page",
+  "pain",
+  "pair",
+  "palm",
+  "park",
+  "part",
+  "pass",
+  "past",
+  "path",
+  "peak",
+  "peel",
+  "peer",
+  "pelt",
+  "pest",
+  "pine",
+  "pink",
+  "pipe",
+  "plan",
+  "play",
+  "plot",
+  "plow",
+  "plug",
+  "plus",
+  "poem",
+  "poet",
+  "pole",
+  "poll",
+  "pond",
+  "pool",
+  "poor",
+  "port",
+  "pose",
+  "post",
+  "pour",
+  "prey",
+  "prop",
+  "pull",
+  "pump",
+  "pure",
+  "push",
+  "race",
+  "rack",
+  "rain",
+  "ramp",
+  "rang",
+  "rank",
+  "rate",
+  "read",
+  "real",
+  "reap",
+  "reed",
+  "reef",
+  "reel",
+  "rely",
+  "rest",
+  "rice",
+  "rich",
+  "ride",
+  "rift",
+  "ring",
+  "rise",
+  "risk",
+  "road",
+  "roam",
+  "roar",
+  "role",
+  "roll",
+  "roof",
+  "room",
+  "root",
+  "rope",
+  "rose",
+  "rove",
+  "ruin",
+  "rule",
+  "rush",
+  "safe",
+  "sage",
+  "sail",
+  "sake",
+  "salt",
+  "same",
+  "sand",
+  "sane",
+  "sang",
+  "sank",
+  "save",
+  "seal",
+  "seam",
+  "seat",
+  "seed",
+  "seek",
+  "seem",
+  "seep",
+  "self",
+  "sell",
+  "send",
+  "sent",
+  "shed",
+  "shin",
+  "ship",
+  "shop",
+  "shot",
+  "show",
+  "shut",
+  "sick",
+  "side",
+  "sift",
+  "sign",
+  "silk",
+  "sill",
+  "sing",
+  "sink",
+  "site",
+  "size",
+  "skin",
+  "slab",
+  "slam",
+  "slap",
+  "slid",
+  "slim",
+  "slip",
+  "slot",
+  "slow",
+  "slug",
+  "snap",
+  "snow",
+  "soak",
+  "soar",
+  "sock",
+  "soft",
+  "soil",
+  "sole",
+  "some",
+  "song",
+  "soot",
+  "sort",
+  "soul",
+  "soup",
+  "sour",
+  "span",
+  "spar",
+  "spin",
+  "spot",
+  "spur",
+  "star",
+  "stay",
+  "stem",
+  "step",
+  "stir",
+  "stop",
+  "stub",
+  "such",
+  "suit",
+  "sung",
+  "sunk",
+  "sure",
+  "surf",
+  "swap",
+  "swim",
+  "tack",
+  "tale",
+  "tall",
+  "tame",
+  "tank",
+  "tape",
+  "task",
+  "team",
+  "tear",
+  "tell",
+  "tend",
+  "tent",
+  "term",
+  "test",
+  "text",
+  "than",
+  "that",
+  "them",
+  "then",
+  "they",
+  "thin",
+  "this",
+  "tide",
+  "tilt",
+  "time",
+  "tiny",
+  "tire",
+  "toad",
+  "toll",
+  "tone",
+  "took",
+  "tool",
+  "tops",
+  "tore",
+  "torn",
+  "toss",
+  "tour",
+  "town",
+  "tray",
+  "trim",
+  "trio",
+  "trip",
+  "true",
+  "tube",
+  "tuck",
+  "tuft",
+  "tune",
+  "turf",
+  "turn",
+  "tusk",
+  "twin",
+  "type",
+  "unit",
+  "upon",
+  "used",
+  "user",
+  "vast",
+  "veil",
+  "very",
+  "vest",
+  "view",
+  "vine",
+  "void",
+  "vote",
+  "wade",
+  "wage",
+  "wake",
+  "walk",
+  "wall",
+  "want",
+  "ward",
+  "warm",
+  "warp",
+  "wary",
+  "wash",
+  "wave",
+  "weak",
+  "weld",
+  "well",
+  "went",
+  "west",
+  "what",
+  "when",
+  "whip",
+  "whom",
+  "wide",
+  "wife",
+  "wild",
+  "will",
+  "wilt",
+  "wind",
+  "wing",
+  "wink",
+  "wire",
+  "wise",
+  "wish",
+  "with",
+  "wolf",
+  "wood",
+  "wore",
+  "worm",
+  "wove",
+  "wrap",
+  "wren",
+  "yard",
+  "yarn",
+  "yell",
+  "your",
+  "zinc",
+  "zone",
+  "zoom"
+];
+WORD_LIST.length;
+function getRandomWordIndex(listLength) {
+  if (listLength <= 256) {
+    const maxValid = 256 - 256 % listLength;
+    const buf = new Uint8Array(1);
+    let b;
+    do {
+      crypto.getRandomValues(buf);
+      b = buf[0];
+    } while (b >= maxValid);
+    return b % listLength;
+  } else {
+    const RANGE40 = 1099511627776;
+    const maxValid = Math.floor(RANGE40 / listLength) * listLength;
+    const buf = new Uint8Array(5);
+    let n;
+    do {
+      crypto.getRandomValues(buf);
+      n = buf[0] * 4294967296 + ((buf[1] << 24 | buf[2] << 16 | buf[3] << 8 | buf[4]) >>> 0);
+    } while (n >= maxValid);
+    return n % listLength;
+  }
+}
+function generatePassphrase(options = {}) {
+  const {
+    words = 4,
+    separator = "-",
+    capitalize = false,
+    appendDigit = false,
+    customWords,
+    prefix
+  } = options;
+  if (words < 2) throw new Error("words must be at least 2.");
+  const wordList = customWords ?? WORD_LIST;
+  if (wordList.length < 2) throw new Error("Word list must contain at least 2 words.");
+  const selected = [];
+  for (let i = 0; i < words; i++) {
+    const idx = getRandomWordIndex(wordList.length);
+    let word = wordList[idx];
+    if (capitalize) word = word.charAt(0).toUpperCase() + word.slice(1);
+    selected.push(word);
+  }
+  let passphrase = selected.join(separator);
+  if (appendDigit) {
+    const digit = getRandomChar("0123456789");
+    passphrase += digit;
+  }
+  if (prefix) passphrase = prefix + passphrase;
+  const entropyBits = Math.log2(Math.pow(wordList.length, words)) + (appendDigit ? Math.log2(10) : 0);
+  return {
+    passphrase,
+    wordCount: words,
+    entropyBits: Math.round(entropyBits * 10) / 10
+  };
+}
+
+// src/entropy.ts
+function estimateEntropy(options = {}) {
+  const {
+    length = 16,
+    prefix = "",
+    suffix = "",
+    pattern,
+    count: _count,
+    startWith: _startWith,
+    ...charsetOptions
+  } = options;
+  if (pattern) {
+    return estimatePatternEntropy(pattern, charsetOptions);
+  }
+  const charset = buildCharset(charsetOptions);
+  const charsetSize = charset.length;
+  const effectiveLength = Math.max(0, length - prefix.length - suffix.length);
+  if (effectiveLength === 0) {
+    return {
+      bits: 0,
+      strength: "very-weak",
+      charsetSize,
+      effectiveLength: 0,
+      combinations: "1"
+    };
+  }
+  const bitsPerChar = Math.log2(charsetSize);
+  const bits = bitsPerChar * effectiveLength;
+  return {
+    bits: Math.round(bits * 100) / 100,
+    strength: strengthLabel(bits),
+    charsetSize,
+    effectiveLength,
+    combinations: approximateCombinations(charsetSize, effectiveLength)
+  };
+}
+function estimatePatternEntropy(pattern, charsetOptions) {
+  const fullCharset = buildCharset(charsetOptions);
+  [...fullCharset].filter((c) => /[a-zA-Z]/.test(c)).join("");
+  const upperChars = [...fullCharset].filter((c) => /[A-Z]/.test(c)).join("");
+  const lowerChars = [...fullCharset].filter((c) => /[a-z]/.test(c)).join("");
+  const digitChars = "0123456789";
+  const alphanumChars = [...fullCharset].filter((c) => /[a-zA-Z0-9]/.test(c)).join("");
+  let totalBits = 0;
+  let effectiveLength = 0;
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "\\" && i + 1 < pattern.length) {
+      i += 2;
+      continue;
+    }
+    let placeholderCharsetSize = 0;
+    switch (ch) {
+      case "#":
+        placeholderCharsetSize = digitChars.length;
+        effectiveLength++;
+        break;
+      case "A":
+        placeholderCharsetSize = Math.max(upperChars.length, 1);
+        effectiveLength++;
+        break;
+      case "a":
+        placeholderCharsetSize = Math.max(lowerChars.length, 1);
+        effectiveLength++;
+        break;
+      case "*":
+        placeholderCharsetSize = fullCharset.length;
+        effectiveLength++;
+        break;
+      case "?":
+        placeholderCharsetSize = Math.max(alphanumChars.length, 1);
+        effectiveLength++;
+        break;
+    }
+    if (placeholderCharsetSize > 0) {
+      totalBits += Math.log2(placeholderCharsetSize);
+    }
+    i++;
+  }
+  return {
+    bits: Math.round(totalBits * 100) / 100,
+    strength: strengthLabel(totalBits),
+    charsetSize: fullCharset.length,
+    effectiveLength,
+    combinations: approximateCombinations(fullCharset.length, effectiveLength)
+  };
+}
+function strengthLabel(bits) {
+  if (bits < 28) return "very-weak";
+  if (bits < 50) return "weak";
+  if (bits < 72) return "fair";
+  if (bits < 100) return "strong";
+  return "very-strong";
+}
+function approximateCombinations(charsetSize, length) {
+  const log10 = length * Math.log10(charsetSize);
+  if (log10 > 15) {
+    const exp = Math.floor(log10);
+    const mantissa = Math.pow(10, log10 - exp);
+    return `${mantissa.toFixed(2)}e+${exp}`;
+  }
+  return Math.round(Math.pow(charsetSize, length)).toString();
+}
+
+// src/validate.ts
+var DIGIT_RE = /[0-9]/;
+var LOWER_RE = /[a-z]/;
+var UPPER_RE = /[A-Z]/;
+var SYMBOL_RE = /[!@#$%^&*()_+\[\]{}<>?]/;
+function validateRandomString(str, options = {}) {
+  const errors = [];
+  const {
+    minLength,
+    maxLength,
+    length,
+    requireNumeric,
+    requireLowercase,
+    requireUppercase,
+    requireSymbols,
+    charset,
+    pattern
+  } = options;
+  if (length !== void 0 && str.length !== length) {
+    errors.push(`Length must be exactly ${length}, got ${str.length}.`);
+  }
+  if (minLength !== void 0 && str.length < minLength) {
+    errors.push(`Length must be at least ${minLength}, got ${str.length}.`);
+  }
+  if (maxLength !== void 0 && str.length > maxLength) {
+    errors.push(`Length must be at most ${maxLength}, got ${str.length}.`);
+  }
+  if (requireNumeric && !DIGIT_RE.test(str)) {
+    errors.push("Must contain at least one numeric digit.");
+  }
+  if (requireLowercase && !LOWER_RE.test(str)) {
+    errors.push("Must contain at least one lowercase letter.");
+  }
+  if (requireUppercase && !UPPER_RE.test(str)) {
+    errors.push("Must contain at least one uppercase letter.");
+  }
+  if (requireSymbols && !SYMBOL_RE.test(str)) {
+    errors.push("Must contain at least one symbol.");
+  }
+  if (charset !== void 0) {
+    const charsetSet = new Set(charset);
+    const invalidChars = [...new Set(str)].filter((ch) => !charsetSet.has(ch));
+    if (invalidChars.length > 0) {
+      errors.push(
+        `Contains characters not in the allowed charset: ${invalidChars.map((c) => JSON.stringify(c)).join(", ")}.`
+      );
+    }
+  }
+  if (pattern !== void 0) {
+    const patternErrors = validatePattern(str, pattern);
+    errors.push(...patternErrors);
+  }
+  return { valid: errors.length === 0, errors };
+}
+function validatePattern(str, pattern) {
+  const errors = [];
+  const expandedPattern = [];
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "\\" && i + 1 < pattern.length) {
+      expandedPattern.push({ type: "literal", value: pattern[i + 1] });
+      i += 2;
+    } else if (["#", "A", "a", "*", "?"].includes(ch)) {
+      expandedPattern.push({ type: "placeholder", value: ch });
+      i++;
+    } else {
+      expandedPattern.push({ type: "literal", value: ch });
+      i++;
+    }
+  }
+  if (str.length !== expandedPattern.length) {
+    errors.push(
+      `Pattern expects length ${expandedPattern.length}, got ${str.length}.`
+    );
+    return errors;
+  }
+  for (let pos = 0; pos < expandedPattern.length; pos++) {
+    const token = expandedPattern[pos];
+    const ch = str[pos];
+    if (token.type === "literal") {
+      if (ch !== token.value) {
+        errors.push(
+          `Position ${pos}: expected literal '${token.value}', got '${ch}'.`
+        );
+      }
+    } else {
+      switch (token.value) {
+        case "#":
+          if (!DIGIT_RE.test(ch)) {
+            errors.push(`Position ${pos}: '#' expects a digit, got '${ch}'.`);
+          }
+          break;
+        case "A":
+          if (!/[A-Z]/.test(ch)) {
+            errors.push(`Position ${pos}: 'A' expects an uppercase letter, got '${ch}'.`);
+          }
+          break;
+        case "a":
+          if (!LOWER_RE.test(ch)) {
+            errors.push(`Position ${pos}: 'a' expects a lowercase letter, got '${ch}'.`);
+          }
+          break;
+        case "?":
+          if (!/[a-zA-Z0-9]/.test(ch)) {
+            errors.push(`Position ${pos}: '?' expects an alphanumeric character, got '${ch}'.`);
+          }
+          break;
+      }
+    }
+  }
+  return errors;
+}
+
+// src/presets.ts
+var PRESETS = {
+  /**
+   * API token / session key.
+   * 32-char alphanumeric (no symbols), readable=false for max entropy.
+   * ~190 bits of entropy.
+   */
+  TOKEN: {
+    length: 32,
+    numeric: true,
+    lowercase: true,
+    uppercase: true,
+    symbols: false
+  },
+  /**
+   * Strong password.
+   * 20 chars, all character types including symbols.
+   * ~131 bits of entropy.
+   */
+  PASSWORD: {
+    length: 20,
+    numeric: true,
+    lowercase: true,
+    uppercase: true,
+    symbols: true
+  },
+  /**
+   * Human-readable token — no ambiguous characters (0/O/l/I/1).
+   * Safe to read aloud or transcribe from a screen.
+   * 16 chars, ~93 bits of entropy.
+   */
+  READABLE: {
+    length: 16,
+    numeric: true,
+    lowercase: true,
+    uppercase: true,
+    symbols: false,
+    readable: true
+  },
+  /**
+   * URL-safe slug identifier.
+   * Lowercase letters and digits only, starts with a letter.
+   * 12 chars, ~62 bits of entropy.
+   */
+  SLUG: {
+    length: 12,
+    numeric: true,
+    lowercase: true,
+    uppercase: false,
+    symbols: false,
+    startWith: "alphabet"
+  },
+  /**
+   * Lowercase hex string.
+   * Compatible with UUID hex components, color codes, hash representations.
+   * 32 chars (128-bit equivalent), ~128 bits of entropy.
+   */
+  HEX: {
+    length: 32,
+    charset: "0123456789abcdef"
+  },
+  /**
+   * Numeric PIN code. 6 digits, starts with a non-zero digit.
+   * ~17 bits of entropy — suitable for short-lived OTP codes.
+   */
+  PIN: {
+    length: 6,
+    numeric: true,
+    lowercase: false,
+    uppercase: false,
+    symbols: false,
+    exclude: "0",
+    startWith: "numeric"
+  },
+  /**
+   * UUID-like string (not RFC 4122 compliant, but same visual format).
+   * Uses `pattern` to produce 8-4-4-4-12 hex grouping.
+   * ~122 bits of entropy (same as UUIDv4).
+   */
+  UUID_LIKE: {
+    pattern: "\\*\\*\\*\\*\\*\\*\\*\\*-\\*\\*\\*\\*-\\*\\*\\*\\*-\\*\\*\\*\\*-\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*",
+    charset: "0123456789abcdef"
+  },
+  /**
+   * Short alphanumeric ID — suitable for database record IDs.
+   * 8 chars, uppercase alphanumeric, starts with a letter.
+   * ~41 bits — good for IDs when combined with a namespace/prefix.
+   */
+  SHORT_ID: {
+    length: 8,
+    numeric: true,
+    lowercase: false,
+    uppercase: true,
+    symbols: false,
+    startWith: "alphabet"
+  },
+  /**
+   * Invitation / redemption code.
+   * 16 chars, readable (no ambiguous chars), pattern grouped for readability.
+   * @example 'KXPZ-9MR2-LQ4Y-8WVN'
+   */
+  INVITE_CODE: {
+    pattern: "AAAA-AAAA-AAAA-AAAA",
+    readable: true
+  }
+};
+
+// src/zod.ts
+function randomStringSchema(options = {}, zod) {
+  let z;
+  if (zod) {
+    z = zod;
+  } else {
+    try {
+      const req = typeof globalThis !== "undefined" && globalThis["require"];
+      z = req ? req("zod") : (() => {
+        throw new Error("no require");
+      })();
+    } catch {
+      throw new Error(
+        "@ppabari/strio: Zod is not installed. Run `npm install zod` or pass the `z` object explicitly: `randomStringSchema(options, z)`."
+      );
+    }
+  }
+  const { description, ...validateOpts } = options;
+  let schema = z.string().refine(
+    (val) => {
+      const result = validateRandomString(val, validateOpts);
+      return result.valid;
+    },
+    {
+      message: buildMessage(validateOpts)
+    }
+  );
+  if (description) {
+    schema = schema.describe(description);
+  }
+  return schema;
+}
+function buildMessage(opts) {
+  const parts = [];
+  if (opts.length !== void 0) parts.push(`exactly ${opts.length} characters`);
+  if (opts.minLength !== void 0) parts.push(`at least ${opts.minLength} characters`);
+  if (opts.maxLength !== void 0) parts.push(`at most ${opts.maxLength} characters`);
+  if (opts.requireNumeric) parts.push("at least one digit");
+  if (opts.requireLowercase) parts.push("at least one lowercase letter");
+  if (opts.requireUppercase) parts.push("at least one uppercase letter");
+  if (opts.requireSymbols) parts.push("at least one symbol");
+  if (opts.charset) parts.push(`only characters from '${opts.charset}'`);
+  if (opts.pattern) parts.push(`matching pattern '${opts.pattern}'`);
+  return parts.length > 0 ? `String must contain ${parts.join(", ")}.` : "Invalid string format.";
+}
+
+// src/secrets.ts
+function randomBytes(length) {
+  if (length <= 0 || !Number.isInteger(length)) {
+    throw new RangeError(`length must be a positive integer, got ${length}.`);
+  }
+  const buf = new Uint8Array(length);
+  crypto.getRandomValues(buf);
+  return buf;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function bytesToBase64(bytes) {
+  return btoa(String.fromCharCode(...bytes));
+}
+function bytesToBase64Url(bytes) {
+  return bytesToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function generateBytes(length) {
+  return randomBytes(length);
+}
+function generateHexKey(bits = 256) {
+  if (bits <= 0 || bits % 8 !== 0) {
+    throw new RangeError(`bits must be a positive multiple of 8, got ${bits}.`);
+  }
+  return bytesToHex(randomBytes(bits / 8));
+}
+function generateBase64Key(bits = 256, variant = "url-safe-no-pad") {
+  if (bits <= 0 || bits % 8 !== 0) {
+    throw new RangeError(`bits must be a positive multiple of 8, got ${bits}.`);
+  }
+  const bytes = randomBytes(bits / 8);
+  switch (variant) {
+    case "standard":
+      return bytesToBase64(bytes);
+    case "url-safe":
+      return bytesToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_");
+    case "url-safe-no-pad":
+      return bytesToBase64Url(bytes);
+    default:
+      throw new TypeError(`Unknown variant '${variant}'. Use 'standard', 'url-safe', or 'url-safe-no-pad'.`);
+  }
+}
+var JWT_MIN_BITS = {
+  HS256: 256,
+  HS384: 384,
+  HS512: 512
+};
+function generateJwtSecret(options = {}) {
+  const {
+    algorithm = "HS256",
+    format = "base64url",
+    bits: bitsOverride
+  } = options;
+  const minBits = JWT_MIN_BITS[algorithm];
+  if (!minBits) {
+    throw new TypeError(
+      `Unknown algorithm '${algorithm}'. Supported: ${Object.keys(JWT_MIN_BITS).join(", ")}.`
+    );
+  }
+  if (bitsOverride !== void 0 && bitsOverride < minBits) {
+    throw new RangeError(
+      `${algorithm} requires at least ${minBits} bits. Got ${bitsOverride}. Use bits >= ${minBits} or omit the bits option.`
+    );
+  }
+  const bits = bitsOverride ?? minBits;
+  if (bits % 8 !== 0) {
+    throw new RangeError(`bits must be a multiple of 8, got ${bits}.`);
+  }
+  const bytes = randomBytes(bits / 8);
+  let secret;
+  switch (format) {
+    case "base64url":
+      secret = bytesToBase64Url(bytes);
+      break;
+    case "hex":
+      secret = bytesToHex(bytes);
+      break;
+    case "utf8-like": {
+      const B622 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+      const charsNeeded = Math.ceil(bits / Math.log2(62));
+      const resultChars = [];
+      const maxValid = 256 - 256 % 62;
+      const drawBuf = new Uint8Array(charsNeeded * 2);
+      crypto.getRandomValues(drawBuf);
+      for (const b of drawBuf) {
+        if (b < maxValid) {
+          resultChars.push(B622[b % 62]);
+          if (resultChars.length >= charsNeeded) break;
+        }
+      }
+      secret = resultChars.join("");
+      break;
+    }
+    default:
+      throw new TypeError(`Unknown format '${format}'.`);
+  }
+  const example = format === "base64url" ? `jwt.sign(payload, '${secret.slice(0, 8)}...', { algorithm: '${algorithm}' })` : `jwt.sign(payload, Buffer.from('${secret.slice(0, 8)}...', '${format === "hex" ? "hex" : "utf8"}'), { algorithm: '${algorithm}' })`;
+  return { secret, algorithm, bits, format, example };
+}
+function generateApiKey(options = {}) {
+  const {
+    type = "sk",
+    environment,
+    bits = 256,
+    charset = "base62",
+    separator = "_"
+  } = options;
+  if (bits <= 0 || bits % 8 !== 0) {
+    throw new RangeError(`bits must be a positive multiple of 8, got ${bits}.`);
+  }
+  const CHARSETS2 = {
+    base62: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+    base58: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+    hex: "0123456789abcdef"
+  };
+  const cs = CHARSETS2[charset] ?? charset;
+  if (cs.length < 2) throw new TypeError(`charset '${charset}' resolves to fewer than 2 unique characters.`);
+  const charsNeeded = Math.ceil(bits / Math.log2(cs.length));
+  const maxValid = 256 - 256 % cs.length;
+  const randomChars = [];
+  const buf = new Uint8Array(charsNeeded * 2 + 64);
+  while (randomChars.length < charsNeeded) {
+    crypto.getRandomValues(buf);
+    for (const b of buf) {
+      if (b < maxValid) {
+        randomChars.push(cs[b % cs.length]);
+        if (randomChars.length >= charsNeeded) break;
+      }
+    }
+  }
+  const randomPortion = randomChars.join("");
+  const prefixParts = [type, environment].filter(Boolean);
+  const prefix = prefixParts.join(separator);
+  const key = prefix + separator + randomPortion;
+  return { key, prefix, randomLength: charsNeeded, bits };
+}
+function generateOtp(options = {}) {
+  const { digits = 6, allowLeadingZero = true } = options;
+  if (digits < 1 || digits > 10) {
+    throw new RangeError(`digits must be between 1 and 10, got ${digits}.`);
+  }
+  const max = Math.pow(10, digits);
+  let n;
+  if (digits <= 9) {
+    const maxValid = Math.floor(4294967296 / max) * max;
+    const buf = new Uint8Array(4);
+    do {
+      crypto.getRandomValues(buf);
+      n = (buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]) >>> 0;
+    } while (n >= maxValid);
+  } else {
+    const RANGE40 = 1099511627776;
+    const maxValid40 = Math.floor(RANGE40 / max) * max;
+    const buf = new Uint8Array(5);
+    do {
+      crypto.getRandomValues(buf);
+      n = buf[0] * 4294967296 + ((buf[1] << 24 | buf[2] << 16 | buf[3] << 8 | buf[4]) >>> 0);
+    } while (n >= maxValid40);
+  }
+  let value = n % max;
+  if (!allowLeadingZero && digits > 1) {
+    const minValue = Math.pow(10, digits - 1);
+    if (value < minValue) {
+      const range = max - minValue;
+      if (digits <= 9) {
+        const maxValid = Math.floor(4294967296 / range) * range;
+        const buf2 = new Uint8Array(4);
+        let m;
+        do {
+          crypto.getRandomValues(buf2);
+          m = (buf2[0] << 24 | buf2[1] << 16 | buf2[2] << 8 | buf2[3]) >>> 0;
+        } while (m >= maxValid);
+        value = minValue + m % range;
+      } else {
+        const RANGE40 = 1099511627776;
+        const maxValid40 = Math.floor(RANGE40 / range) * range;
+        const buf2 = new Uint8Array(5);
+        let m;
+        do {
+          crypto.getRandomValues(buf2);
+          m = buf2[0] * 4294967296 + ((buf2[1] << 24 | buf2[2] << 16 | buf2[3] << 8 | buf2[4]) >>> 0);
+        } while (m >= maxValid40);
+        value = minValue + m % range;
+      }
+    }
+  }
+  const code = value.toString().padStart(digits, "0");
+  return { code, value, digits };
+}
+function maskSecret(secret, options = {}) {
+  if (!secret) return "";
+  const {
+    visibleStart = 0,
+    visibleEnd = 4,
+    maskChar = "*",
+    minMaskLength = 4,
+    maxMaskLength = 8,
+    knownPrefixes = [
+      "strio_live_",
+      "strio_test_",
+      "strio_dev_",
+      "myapp_live_",
+      "myapp_test_",
+      "myapp_dev_",
+      "tok_",
+      "api_",
+      "key_"
+    ]
+  } = options;
+  let prefix = "";
+  let payload = secret;
+  for (const kp of knownPrefixes) {
+    if (secret.startsWith(kp)) {
+      prefix = kp;
+      payload = secret.slice(kp.length);
+      break;
+    }
+  }
+  const totalLen = payload.length;
+  const showStart = Math.min(visibleStart, totalLen);
+  const showEnd = Math.min(visibleEnd, totalLen - showStart);
+  const hiddenLen = totalLen - showStart - showEnd;
+  if (hiddenLen <= 0) {
+    return prefix + maskChar.repeat(minMaskLength);
+  }
+  const maskLen = Math.max(minMaskLength, Math.min(maxMaskLength, hiddenLen));
+  const mask = maskChar.repeat(maskLen);
+  const startPart = showStart > 0 ? payload.slice(0, showStart) : "";
+  const endPart = showEnd > 0 ? payload.slice(totalLen - showEnd) : "";
+  return `${prefix}${startPart}${mask}...${endPart}`;
+}
+function timingSafeEqual(a, b) {
+  const encoder = new TextEncoder();
+  const bufA = typeof a === "string" ? encoder.encode(a) : a;
+  const bufB = typeof b === "string" ? encoder.encode(b) : b;
+  const len = Math.max(bufA.length, bufB.length);
+  const padA = new Uint8Array(len);
+  const padB = new Uint8Array(len);
+  padA.set(bufA);
+  padB.set(bufB);
+  let diff = bufA.length === bufB.length ? 0 : 1;
+  for (let i = 0; i < len; i++) {
+    diff |= padA[i] ^ padB[i];
+  }
+  return diff === 0;
+}
+function generateCookieSecret(bits = 256) {
+  if (bits < 128) throw new RangeError("Cookie secret should be at least 128 bits.");
+  return generateBase64Key(bits, "url-safe-no-pad");
+}
+function generateAesKey(keySize = 256, format = "hex") {
+  const bytes = randomBytes(keySize / 8);
+  if (format === "bytes") return bytes;
+  if (format === "hex") return bytesToHex(bytes);
+  return bytesToBase64Url(bytes);
+}
+function generateNextAuthSecret() {
+  return generateBase64Key(256, "url-safe-no-pad");
+}
+function generateDjangoSecretKey() {
+  const DJANGO_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const length = 64;
+  const maxValid = 256 - 256 % DJANGO_CHARS.length;
+  const chars = [];
+  const buf = new Uint8Array(length * 2);
+  while (chars.length < length) {
+    crypto.getRandomValues(buf);
+    for (const b of buf) {
+      if (b < maxValid) {
+        chars.push(DJANGO_CHARS[b % DJANGO_CHARS.length]);
+        if (chars.length >= length) break;
+      }
+    }
+  }
+  return chars.join("");
+}
+function generateRailsSecretKeyBase() {
+  return generateHexKey(512);
+}
+
+// src/index.ts
+function generateRandomString(options = {}) {
+  const { count = 1, ...rest } = options;
+  if (count === 1) return generateOne(rest);
+  return generateBatch(rest, count);
+}
+async function generateRandomStringAsync(options = {}) {
+  await Promise.resolve();
+  const { count = 1, ...rest } = options;
+  if (count === 1) return generateOne(rest);
+  return generateBatch(rest, count);
+}
+
+exports.BUILT_IN_WORD_LIST = WORD_LIST;
+exports.CHARSET_ALIASES = CHARSET_ALIASES;
+exports.PRESETS = PRESETS;
+exports.estimateEntropy = estimateEntropy;
+exports.generateAesKey = generateAesKey;
+exports.generateApiKey = generateApiKey;
+exports.generateBase64Key = generateBase64Key;
+exports.generateBytes = generateBytes;
+exports.generateCookieSecret = generateCookieSecret;
+exports.generateDjangoSecretKey = generateDjangoSecretKey;
+exports.generateExpiringToken = generateExpiringToken;
+exports.generateHexKey = generateHexKey;
+exports.generateId = generateId;
+exports.generateJwtSecret = generateJwtSecret;
+exports.generateNextAuthSecret = generateNextAuthSecret;
+exports.generateOtp = generateOtp;
+exports.generatePassphrase = generatePassphrase;
+exports.generateRailsSecretKeyBase = generateRailsSecretKeyBase;
+exports.generateRandomString = generateRandomString;
+exports.generateRandomStringAsync = generateRandomStringAsync;
+exports.maskSecret = maskSecret;
+exports.randomStringSchema = randomStringSchema;
+exports.randomStringStream = randomStringStream;
+exports.resolveCharsetAlias = resolveCharsetAlias;
+exports.take = take;
+exports.takeWhere = takeWhere;
+exports.timingSafeEqual = timingSafeEqual;
+exports.uniqueRandomStringStream = uniqueRandomStringStream;
+exports.validateId = validateId;
+exports.validateRandomString = validateRandomString;
+exports.verifyToken = verifyToken;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map