@ppabari/strio 1.0.2

package/dist/bin/strio.js

@@ -0,0 +1,1492 @@
+#!/usr/bin/env node
+
+// 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, count2) {
+  const len = charset.length;
+  const maxValid = 256 - 256 % len;
+  const result = [];
+  const bufSize = Math.ceil(count2 * 1.4) + 32;
+  const buf = new Uint8Array(bufSize);
+  while (result.length < count2) {
+    crypto.getRandomValues(buf);
+    for (let i = 0; i < buf.length && result.length < count2; 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",
+  hex: "0123456789abcdef",
+  // Ambiguous characters that are easy to confuse when reading/transcribing
+  ambiguous: "0Ol1I"
+};
+function dedup(str) {
+  return [...new Set(str)].join("");
+}
+function buildCharset(options2) {
+  let pool;
+  if (options2.charset !== void 0) {
+    pool = dedup(resolveCharsetAlias(options2.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
+  } = options2;
+  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 (options2.readable) {
+    for (const ch of CHARSETS.ambiguous) {
+      pool = pool.split(ch).join("");
+    }
+  }
+  if (options2.exclude) {
+    const excludeChars = typeof options2.exclude === "string" ? options2.exclude : options2.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(options2) {
+  const {
+    length = 16,
+    prefix = "",
+    suffix = "",
+    startWith = "any",
+    pattern,
+    seed,
+    ...charsetOptions
+  } = options2;
+  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(options2, count2) {
+  if (count2 <= 0) {
+    throw new Error("count must be a positive integer.");
+  }
+  if (!Number.isInteger(count2)) {
+    throw new Error("count must be an integer.");
+  }
+  const results = /* @__PURE__ */ new Set();
+  let attempts = 0;
+  const maxAttempts = count2 * 10 + 1e3;
+  while (results.size < count2) {
+    if (++attempts > maxAttempts) {
+      throw new Error(
+        `Could not generate ${count2} unique strings after ${maxAttempts} attempts. The charset and length combination may not support this many unique values.`
+      );
+    }
+    results.add(generateOne(options2));
+  }
+  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(options2 = {}) {
+  const {
+    prefix,
+    separator = "_",
+    randomLength = 12,
+    charset: rawCharset = "base58",
+    checksum = true
+  } = options2;
+  const resolvedCharset2 = resolveCharsetAlias(rawCharset);
+  const charset = buildCharset({ charset: resolvedCharset2 });
+  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;
+}
+
+// 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 generateExpiringToken(options2 = {}) {
+  const { ttlSeconds = 900, payloadLength = 24 } = options2;
+  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
+  };
+}
+
+// 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"
+];
+var WORD_COUNT = 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(options2 = {}) {
+  const {
+    words = 4,
+    separator = "-",
+    capitalize = false,
+    appendDigit = false,
+    customWords,
+    prefix
+  } = options2;
+  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(options2 = {}) {
+  const {
+    length = 16,
+    prefix = "",
+    suffix = "",
+    pattern,
+    count: _count,
+    startWith: _startWith,
+    ...charsetOptions
+  } = options2;
+  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);
+  const alphaChars = [...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;
+      default:
+        break;
+    }
+    if (placeholderCharsetSize > 0) {
+      totalBits += Math.log2(placeholderCharsetSize);
+    }
+    i++;
+  }
+  const _ = alphaChars;
+  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/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/index.ts
+function generateRandomString(options2 = {}) {
+  const { count: count2 = 1, ...rest } = options2;
+  if (count2 === 1) return generateOne(rest);
+  return generateBatch(rest, count2);
+}
+
+// bin/strio.ts
+var args = process.argv.slice(2);
+function getFlag(name) {
+  const i = args.indexOf(`--${name}`);
+  return i !== -1 ? args[i + 1] : void 0;
+}
+function hasFlag(name) {
+  return args.includes(`--${name}`);
+}
+if (hasFlag("help") || hasFlag("h")) {
+  console.log(`
+  @ppabari/strio \u2014 cryptographically secure string generation
+
+  USAGE
+    npx @ppabari/strio [options]
+
+  GENERATION OPTIONS
+    --length <n>          String length (default: 16)
+    --count <n>           Generate N strings (one per line)
+    --preset <name>       Use a named preset (see PRESETS below)
+    --pattern <str>       Pattern mode: # digit, A uppercase, a lowercase, * any, ? alnum
+    --charset <name|str>  Named alias or raw charset string
+    --no-numeric          Exclude digits
+    --no-lowercase        Exclude lowercase letters
+    --no-uppercase        Exclude uppercase letters
+    --symbols             Include symbols
+    --readable            Exclude ambiguous chars (0 O l I 1)
+    --exclude <chars>     Exclude specific characters
+    --prefix <str>        Prepend a fixed string
+    --suffix <str>        Append a fixed string
+    --start-with <type>   First char: alphabet | numeric | any
+
+  SPECIAL MODES
+    --passphrase          Generate a passphrase instead
+      --words <n>         Number of words (default: 4)
+      --separator <str>   Word separator (default: -)
+      --capitalize        Capitalize each word
+      --append-digit      Append a random digit
+
+    --id                  Generate a short ID with checksum
+      --prefix <str>      ID prefix (e.g. usr \u2192 usr_...)
+      --id-length <n>     Random portion length (default: 12)
+
+    --expiring            Generate a self-expiring token
+      --ttl <seconds>     Token TTL in seconds (default: 900)
+      --payload <n>       Payload length (default: 24)
+
+    --entropy             Show entropy estimate only (no string generated)
+
+  PRESETS
+    TOKEN       32-char alphanumeric API token
+    PASSWORD    20-char with symbols
+    READABLE    16-char, no ambiguous chars
+    SLUG        12-char lowercase, starts with letter
+    HEX         32-char hex
+    PIN         6-digit PIN
+    SHORT_ID    8-char uppercase, starts with letter
+    INVITE_CODE AAAA-AAAA-AAAA-AAAA
+
+  CHARSET ALIASES
+    base16 base32 base36 base58 base62 base64url hex alphanumeric crockford32
+
+  EXAMPLES
+    npx @ppabari/strio --length 32
+    npx @ppabari/strio --preset TOKEN --count 5
+    npx @ppabari/strio --pattern "####-AAAA-####"
+    npx @ppabari/strio --charset base58 --length 22
+    npx @ppabari/strio --passphrase --words 6 --capitalize
+    npx @ppabari/strio --id --prefix usr
+    npx @ppabari/strio --expiring --ttl 300
+    npx @ppabari/strio --entropy --preset PASSWORD
+`);
+  process.exit(0);
+}
+if (hasFlag("passphrase")) {
+  const words = parseInt(getFlag("words") ?? "4", 10);
+  const separator = getFlag("separator") ?? "-";
+  const capitalize = hasFlag("capitalize");
+  const appendDigit = hasFlag("append-digit");
+  const count2 = parseInt(getFlag("count") ?? "1", 10);
+  for (let i = 0; i < count2; i++) {
+    const { passphrase, entropyBits } = generatePassphrase({ words, separator, capitalize, appendDigit });
+    if (hasFlag("verbose")) {
+      console.log(`${passphrase}  [${entropyBits} bits]`);
+    } else {
+      console.log(passphrase);
+    }
+  }
+  process.exit(0);
+}
+if (hasFlag("id")) {
+  const prefix = getFlag("prefix");
+  const randomLength = parseInt(getFlag("id-length") ?? "12", 10);
+  const charset = getFlag("charset") ?? "base58";
+  const count2 = parseInt(getFlag("count") ?? "1", 10);
+  for (let i = 0; i < count2; i++) {
+    console.log(generateId({ prefix, randomLength, charset }));
+  }
+  process.exit(0);
+}
+if (hasFlag("expiring")) {
+  const ttlSeconds = parseInt(getFlag("ttl") ?? "900", 10);
+  const payloadLength = parseInt(getFlag("payload") ?? "24", 10);
+  const count2 = parseInt(getFlag("count") ?? "1", 10);
+  for (let i = 0; i < count2; i++) {
+    const { token, expiresAt } = generateExpiringToken({ ttlSeconds, payloadLength });
+    if (hasFlag("verbose")) {
+      console.log(`${token}  [expires: ${expiresAt.toISOString()}]`);
+    } else {
+      console.log(token);
+    }
+  }
+  process.exit(0);
+}
+var presetName = getFlag("preset");
+var preset = presetName ? PRESETS[presetName] : void 0;
+if (presetName && !preset) {
+  console.error(`Unknown preset: ${presetName}. Available: ${Object.keys(PRESETS).join(", ")}`);
+  process.exit(1);
+}
+var charsetArg = getFlag("charset");
+var resolvedCharset = charsetArg ? CHARSET_ALIASES[charsetArg] ?? charsetArg : void 0;
+var options = {
+  ...preset ?? {},
+  ...getFlag("length") ? { length: parseInt(getFlag("length"), 10) } : {},
+  ...hasFlag("no-numeric") ? { numeric: false } : {},
+  ...hasFlag("no-lowercase") ? { lowercase: false } : {},
+  ...hasFlag("no-uppercase") ? { uppercase: false } : {},
+  ...hasFlag("symbols") ? { symbols: true } : {},
+  ...hasFlag("readable") ? { readable: true } : {},
+  ...getFlag("exclude") ? { exclude: getFlag("exclude") } : {},
+  ...getFlag("prefix") ? { prefix: getFlag("prefix") } : {},
+  ...getFlag("suffix") ? { suffix: getFlag("suffix") } : {},
+  ...getFlag("start-with") ? { startWith: getFlag("start-with") } : {},
+  ...getFlag("pattern") ? { pattern: getFlag("pattern") } : {},
+  ...resolvedCharset ? { charset: resolvedCharset } : {}
+};
+if (hasFlag("entropy")) {
+  const e = estimateEntropy(options);
+  console.log(`Charset size : ${e.charsetSize} characters`);
+  console.log(`Length       : ${e.effectiveLength} chars (random portion)`);
+  console.log(`Entropy      : ${e.bits} bits`);
+  console.log(`Strength     : ${e.strength}`);
+  console.log(`Combinations : ${e.combinations}`);
+  process.exit(0);
+}
+var count = parseInt(getFlag("count") ?? "1", 10);
+try {
+  if (count === 1) {
+    console.log(generateRandomString(options));
+  } else {
+    const results = generateRandomString({ ...options, count });
+    results.forEach((s) => console.log(s));
+  }
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}