Crypto-random password generator

export type Options = {
  length?: number;
  lower?: boolean;
  upper?: boolean;
  digits?: boolean;
  symbols?: boolean;
  avoidAmbiguous?: boolean;
};

const SETS = {
  lower: 'abcdefghijklmnopqrstuvwxyz',
  upper: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
  digits: '0123456789',
  symbols: '!@#$%^&*()-_=+[]{};:,.?',
} as const;
const AMBIGUOUS = /[O0oIl1|]/g;

// Unbiased integer in [0, max): reject values from the uneven tail.
function randomInt(max: number): number {
  const limit = Math.floor(0x100000000 / max) * max;
  const buf = new Uint32Array(1);
  do {
    crypto.getRandomValues(buf);
  } while (buf[0]! >= limit);
  return buf[0]! % max;
}

function classes(o: Options): string[] {
  const { lower = true, upper = true, digits = true, symbols = false, avoidAmbiguous = false } = o;
  const picked = Object.entries({ lower, upper, digits, symbols })
    .filter(([, on]) => on)
    .map(([name]) => SETS[name as keyof typeof SETS]);
  return picked.map((s) => (avoidAmbiguous ? s.replace(AMBIGUOUS, '') : s)).filter(Boolean);
}

export function generate(o: Options = {}): string {
  const sets = classes(o);
  const length = Math.min(128, Math.max(sets.length, o.length ?? 16));
  if (!sets.length) throw new Error('Select at least one character type');

  const pool = sets.join('');
  // One guaranteed character per class, the rest from the combined pool.
  const out = sets.map((s) => s[randomInt(s.length)]!);
  while (out.length < length) out.push(pool[randomInt(pool.length)]!);

  for (let i = out.length - 1; i > 0; i--) {
    const j = randomInt(i + 1); // Fisher-Yates so guaranteed characters are not first
    [out[i], out[j]] = [out[j]!, out[i]!];
  }
  return out.join('');
}

export function entropyBits(o: Options = {}): number {
  const poolSize = classes(o).join('').length;
  return Math.round((o.length ?? 16) * Math.log2(Math.max(2, poolSize)));
}