@poorvithmp/safegen 2.0.0

package/README.md

@@ -0,0 +1,12 @@
+# @poorvith-mp/safegen
+
+SafeGen's zero-dependency TypeScript core for generating and auditing passwords, passphrases, PINs, and custom patterns with the runtime's native cryptographic random source.
+
+```ts
+import { calculateAudit, generatePassword } from '@poorvith-mp/safegen';
+
+const credential = generatePassword({ length: 20 });
+console.log(credential, calculateAudit(credential));
+```
+
+[Documentation](https://github.com/poorvith-mp/safegen#package-and-cli) · [SafeGen](https://safegen.poorvithmp.com)

package/dist/audit.d.ts

@@ -0,0 +1,5 @@
+import type { PasswordOptions, SecurityAudit } from './types.js';
+export declare function formatCrackTime(seconds: number): string;
+export declare function calculateAudit(password: string, options?: PasswordOptions): SecurityAudit;
+export declare const calculateDetailedAudit: typeof calculateAudit;
+//# sourceMappingURL=audit.d.ts.map

package/dist/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../src/audit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAkB,MAAM,YAAY,CAAC;AAEjF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUvD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,aAAa,CAsC7F;AAED,eAAO,MAAM,sBAAsB,uBAAiB,CAAC"}

package/dist/audit.js

@@ -0,0 +1,73 @@
+import { CHARACTER_SETS, PASSPHRASE_WORDS } from './generator.js';
+export function formatCrackTime(seconds) {
+    if (seconds < 0.001)
+        return 'Instantaneous (< 1 millisecond)';
+    if (seconds < 1)
+        return `${Math.round(seconds * 1000)} milliseconds`;
+    if (seconds < 60)
+        return `${Math.round(seconds)} seconds`;
+    if (seconds < 3_600)
+        return `${Math.round(seconds / 60)} minutes`;
+    if (seconds < 86_400)
+        return `${Math.round(seconds / 3_600)} hours`;
+    if (seconds < 31_536_000)
+        return `${Math.round(seconds / 86_400)} days`;
+    if (seconds < 3_153_600_000)
+        return `${Math.round(seconds / 31_536_000)} years`;
+    if (seconds < 315_360_000_000)
+        return `${Math.round(seconds / 3_153_600_000)} centuries`;
+    return 'Over 1,000 centuries at the stated guess rate';
+}
+export function calculateAudit(password, options = {}) {
+    if (!password)
+        return { entropy: 0, rating: 'Weak', timeToCrackSeconds: 0, crackTime: 'N/A', crackTimeFormatted: 'N/A', poolSize: 0, score: 0, warnings: ['No password generated'], tips: ['Generate a credential before auditing it'] };
+    const hasUpper = [...password].some((char) => CHARACTER_SETS.uppercase.includes(char));
+    const hasLower = [...password].some((char) => CHARACTER_SETS.lowercase.includes(char));
+    const hasNumber = [...password].some((char) => CHARACTER_SETS.numbers.includes(char));
+    const hasSymbol = [...password].some((char) => CHARACTER_SETS.symbols.includes(char));
+    let poolSize = (hasUpper ? 26 : 0) + (hasLower ? 26 : 0) + (hasNumber ? 10 : 0) + (hasSymbol ? CHARACTER_SETS.symbols.length : 0);
+    let entropy;
+    if (options.mode === 'passphrase') {
+        const words = options.words ?? options.wordCount ?? password.split(options.separator ?? '-').length;
+        poolSize = PASSPHRASE_WORDS.length;
+        entropy = words * Math.log2(poolSize) + (options.includeNumber ? Math.log2(words * 100) : 0);
+    }
+    else if (options.mode === 'pin') {
+        poolSize = 10;
+        entropy = password.length * Math.log2(10);
+    }
+    else if (options.mode === 'pattern') {
+        const template = options.template ?? options.pattern ?? '';
+        entropy = [...template].reduce((total, char) => total + (char === 'L' || char === 'l' ? Math.log2(26) : char === 'n' ? Math.log2(10) : char === 'S' || char === 's' ? Math.log2(CHARACTER_SETS.symbols.length) : 0), 0);
+    }
+    else {
+        entropy = password.length * Math.log2(poolSize || 1);
+    }
+    entropy = Math.round(entropy);
+    const timeToCrackSeconds = 2 ** entropy / 200_000_000_000;
+    let rating = entropy < 40 ? 'Weak' : entropy < 65 ? 'Medium' : entropy < 90 ? 'Strong' : 'Very strong';
+    let score = Math.min(100, Math.round(entropy / 90 * 100));
+    if (rating === 'Weak')
+        score = Math.max(10, Math.min(35, score));
+    if (rating === 'Medium')
+        score = Math.max(40, Math.min(68, score));
+    if (rating === 'Strong')
+        score = Math.max(70, Math.min(88, score));
+    const warnings = [];
+    const tips = [];
+    if (password.length < 12)
+        warnings.push('Length is under 12 characters');
+    if (!hasSymbol && (options.mode ?? 'random') === 'random')
+        warnings.push('No special symbols included');
+    if (!hasNumber && (options.mode ?? 'random') === 'random')
+        warnings.push('No numeric digits included');
+    if (entropy >= 80)
+        tips.push('Excellent entropy for high-value accounts');
+    if (options.mode === 'passphrase')
+        tips.push('Passphrases offer high security while remaining easy to type and remember');
+    if ((options.mode ?? 'random') === 'random' && password.length >= 16)
+        tips.push('Resistant to offline dictionary and rainbow table attacks');
+    const crackTime = formatCrackTime(timeToCrackSeconds);
+    return { entropy, rating, timeToCrackSeconds, crackTime, crackTimeFormatted: crackTime, poolSize, score, warnings, tips };
+}
+export const calculateDetailedAudit = calculateAudit;

package/dist/crypto-provider.d.ts

@@ -0,0 +1,2 @@
+export declare function secureRandomInt(max: number): number;
+//# sourceMappingURL=crypto-provider.d.ts.map

package/dist/crypto-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-provider.d.ts","sourceRoot":"","sources":["../src/crypto-provider.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAWnD"}

package/dist/crypto-provider.js

@@ -0,0 +1,14 @@
+export function secureRandomInt(max) {
+    if (!Number.isSafeInteger(max) || max <= 0 || max > 0x1_0000_0000) {
+        throw new RangeError('Random range is invalid');
+    }
+    if (!globalThis.crypto?.getRandomValues) {
+        throw new Error('A native cryptographic random source is required');
+    }
+    const sample = new Uint32Array(1);
+    const limit = Math.floor(0x1_0000_0000 / max) * max;
+    do
+        globalThis.crypto.getRandomValues(sample);
+    while (sample[0] >= limit);
+    return sample[0] % max;
+}

package/dist/generator.d.ts

@@ -0,0 +1,17 @@
+import { secureRandomInt } from './crypto-provider.js';
+import type { PassphraseOptions, PasswordOptions, PatternOptions, PinOptions, RandomPasswordOptions } from './types.js';
+export declare const CHARACTER_SETS: {
+    readonly uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    readonly lowercase: "abcdefghijklmnopqrstuvwxyz";
+    readonly numbers: "0123456789";
+    readonly symbols: "!@#$%^&*()_+{}[]<>?/|~=-";
+};
+export declare const PASSPHRASE_WORDS: readonly ["anchor", "beacon", "canvas", "cipher", "cobalt", "crane", "delta", "drift", "echo", "amber", "falcon", "flint", "fossil", "glacier", "granite", "harbor", "horizon", "indigo", "island", "jasper", "lagoon", "lunar", "magnet", "marble", "matrix", "meridian", "meteor", "nexus", "noble", "oasis", "obsidian", "orbit", "opal", "origin", "phantom", "phoenix", "prism", "pulse", "pyramid", "quartz", "radar", "radius", "raven", "ripple", "ruby", "safari", "sapphire", "saturn", "shadow", "shield", "signal", "silicon", "solar", "sonic", "spectrum", "sphere", "summit", "tactic", "timber", "titan", "topaz", "torpedo", "trace", "tropic", "tundra", "vector", "velocity", "velvet", "vessel", "vortex", "whisper", "zenith", "astral", "breeze", "canyon", "cascade", "celestial", "citadel", "comet", "crest", "crystal", "eclipse", "ember", "equinox", "frontier", "galaxy", "haven", "infinity", "kinetic", "lantern", "legacy", "monolith", "nebula", "odyssey", "pioneer", "quantum", "sanctuary", "solace", "stellar", "symphony", "vanguard", "vista", "voyage"];
+export declare const randomInt: typeof secureRandomInt;
+export declare function generatePassword(options?: RandomPasswordOptions): string;
+export declare const generateRandomPassword: typeof generatePassword;
+export declare function generatePassphrase(options?: PassphraseOptions): string;
+export declare function generatePIN(options?: PinOptions): string;
+export declare function generatePattern(options?: PatternOptions): string;
+export declare function generateCredential(options: PasswordOptions): string;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,eAAO,MAAM,gBAAgB,iiCAYnB,CAAC;AAEX,eAAO,MAAM,SAAS,wBAAkB,CAAC;AAazC,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAa5E;AAED,eAAO,MAAM,sBAAsB,yBAAmB,CAAC;AAEvD,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAS1E;AAED,wBAAgB,WAAW,CAAC,OAAO,GAAE,UAAe,GAAG,MAAM,CAI5D;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CASpE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAKnE"}

package/dist/generator.js

@@ -0,0 +1,90 @@
+import { secureRandomInt } from './crypto-provider.js';
+export const CHARACTER_SETS = {
+    uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    lowercase: 'abcdefghijklmnopqrstuvwxyz',
+    numbers: '0123456789',
+    symbols: '!@#$%^&*()_+{}[]<>?/|~=-',
+};
+export const PASSPHRASE_WORDS = [
+    'anchor', 'beacon', 'canvas', 'cipher', 'cobalt', 'crane', 'delta', 'drift', 'echo', 'amber',
+    'falcon', 'flint', 'fossil', 'glacier', 'granite', 'harbor', 'horizon', 'indigo', 'island', 'jasper',
+    'lagoon', 'lunar', 'magnet', 'marble', 'matrix', 'meridian', 'meteor', 'nexus', 'noble', 'oasis',
+    'obsidian', 'orbit', 'opal', 'origin', 'phantom', 'phoenix', 'prism', 'pulse', 'pyramid', 'quartz',
+    'radar', 'radius', 'raven', 'ripple', 'ruby', 'safari', 'sapphire', 'saturn', 'shadow', 'shield',
+    'signal', 'silicon', 'solar', 'sonic', 'spectrum', 'sphere', 'summit', 'tactic', 'timber', 'titan',
+    'topaz', 'torpedo', 'trace', 'tropic', 'tundra', 'vector', 'velocity', 'velvet', 'vessel', 'vortex',
+    'whisper', 'zenith', 'astral', 'breeze', 'canyon', 'cascade', 'celestial', 'citadel', 'comet', 'crest',
+    'crystal', 'eclipse', 'ember', 'equinox', 'frontier', 'galaxy', 'haven', 'infinity', 'kinetic', 'lantern',
+    'legacy', 'monolith', 'nebula', 'odyssey', 'pioneer', 'quantum', 'sanctuary', 'solace', 'stellar',
+    'symphony', 'vanguard', 'vista', 'voyage',
+];
+export const randomInt = secureRandomInt;
+function randomChar(characters) { return characters[randomInt(characters.length)]; }
+function shuffle(values) {
+    const result = [...values];
+    for (let index = result.length - 1; index > 0; index -= 1) {
+        const target = randomInt(index + 1);
+        [result[index], result[target]] = [result[target], result[index]];
+    }
+    return result;
+}
+export function generatePassword(options = {}) {
+    const settings = { length: 16, uppercase: true, lowercase: true, numbers: true, symbols: true, ...options };
+    if (!Number.isInteger(settings.length) || settings.length < 1)
+        throw new RangeError('Password length must be a positive integer');
+    const sets = [
+        settings.uppercase ? CHARACTER_SETS.uppercase : '', settings.lowercase ? CHARACTER_SETS.lowercase : '',
+        settings.numbers ? CHARACTER_SETS.numbers : '', settings.symbols ? CHARACTER_SETS.symbols : '',
+    ].filter(Boolean);
+    if (sets.length === 0)
+        throw new Error('Select at least one character set');
+    if (settings.length < sets.length)
+        throw new RangeError('Password length is shorter than the selected character-set count');
+    const result = sets.map(randomChar);
+    const pool = sets.join('');
+    while (result.length < settings.length)
+        result.push(randomChar(pool));
+    return shuffle(result).join('');
+}
+export const generateRandomPassword = generatePassword;
+export function generatePassphrase(options = {}) {
+    const count = options.words ?? options.wordCount ?? 4;
+    if (!Number.isInteger(count) || count < 1)
+        throw new RangeError('Word count must be a positive integer');
+    const words = Array.from({ length: count }, () => {
+        const word = PASSPHRASE_WORDS[randomInt(PASSPHRASE_WORDS.length)];
+        return options.capitalize ? word[0].toUpperCase() + word.slice(1) : word;
+    });
+    if (options.includeNumber)
+        words[randomInt(words.length)] += randomInt(100);
+    return words.join(options.separator ?? '-');
+}
+export function generatePIN(options = {}) {
+    const length = options.length ?? options.pinLength ?? 6;
+    if (!Number.isInteger(length) || length < 1)
+        throw new RangeError('PIN length must be a positive integer');
+    return Array.from({ length }, () => randomChar(CHARACTER_SETS.numbers)).join('');
+}
+export function generatePattern(options = {}) {
+    const template = options.template ?? options.pattern ?? 'Lnnn-Lnnn-S';
+    return [...template].map((character) => {
+        if (character === 'L')
+            return randomChar(CHARACTER_SETS.uppercase);
+        if (character === 'l')
+            return randomChar(CHARACTER_SETS.lowercase);
+        if (character === 'n')
+            return randomChar(CHARACTER_SETS.numbers);
+        if (character === 'S' || character === 's')
+            return randomChar(CHARACTER_SETS.symbols);
+        return character;
+    }).join('');
+}
+export function generateCredential(options) {
+    if (options.mode === 'passphrase')
+        return generatePassphrase(options);
+    if (options.mode === 'pin')
+        return generatePIN(options);
+    if (options.mode === 'pattern')
+        return generatePattern(options);
+    return generatePassword(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './audit.js';
+export * from './crypto-provider.js';
+export * from './generator.js';
+export type * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,mBAAmB,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './audit.js';
+export * from './crypto-provider.js';
+export * from './generator.js';

package/dist/types.d.ts

@@ -0,0 +1,39 @@
+export type GeneratorMode = 'random' | 'passphrase' | 'pin' | 'pattern';
+export type StrengthRating = 'Weak' | 'Medium' | 'Strong' | 'Very strong';
+export interface RandomPasswordOptions {
+    length?: number;
+    uppercase?: boolean;
+    lowercase?: boolean;
+    numbers?: boolean;
+    symbols?: boolean;
+}
+export interface PassphraseOptions {
+    words?: number;
+    wordCount?: number;
+    separator?: '-' | '_' | '.' | ' ' | string;
+    capitalize?: boolean;
+    includeNumber?: boolean;
+}
+export interface PinOptions {
+    length?: number;
+    pinLength?: number;
+}
+export interface PatternOptions {
+    template?: string;
+    pattern?: string;
+}
+export interface PasswordOptions extends RandomPasswordOptions, PassphraseOptions, PinOptions, PatternOptions {
+    mode?: GeneratorMode;
+}
+export interface SecurityAudit {
+    entropy: number;
+    rating: StrengthRating;
+    timeToCrackSeconds: number;
+    crackTime: string;
+    crackTimeFormatted: string;
+    poolSize: number;
+    score: number;
+    warnings: string[];
+    tips: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,YAAY,GAAG,KAAK,GAAG,SAAS,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;IAC3C,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IAAG,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE;AACnE,MAAM,WAAW,cAAc;IAAG,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE;AAEvE,MAAM,WAAW,eAAgB,SAAQ,qBAAqB,EAAE,iBAAiB,EAAE,UAAU,EAAE,cAAc;IAC3G,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,cAAc,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@poorvithmp/safegen",
+  "version": "2.0.0",
+  "description": "Typed, zero-dependency credential generation and auditing for browsers and Node.js.",
+  "author": "Poorvith M P",
+  "homepage": "https://safegen.poorvithmp.com",
+  "repository": { "type": "git", "url": "git+https://github.com/poorvith-mp/safegen.git", "directory": "packages/core" },
+  "bugs": { "url": "https://github.com/poorvith-mp/safegen/issues" },
+  "keywords": ["password", "passphrase", "credentials", "cryptography", "typescript"],
+  "type": "module",
+  "sideEffects": false,
+  "files": ["dist", "README.md"],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  }
+}