smart-passphrase 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ayush Solanki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# smart-passphrase
+
+A lightweight, secure, and memorable passphrase generator for Node.js and the browser.
+
+---
+
+##  Features
+
+* Human-readable passwords
+* Cryptographically secure randomness
+* Works with React, Next.js, Vite, Node
+* TypeScript support
+
+---
+
+##  Install
+
+```bash
+npm install @ayushsolanki29/smart-passphrase
+```
+
+---
+
+## Usage
+
+```ts
+import { generatePassword } from "@ayushsolanki29/smart-passphrase";
+
+const password = generatePassword();
+console.log(password);
+```
+
+---
+
+##  Example Output
+
+```
+theSOON^goose324
+Ishow#mark=down
+34Roto)mAsk
+```
+
+---
+
+## 📄 License
+
+MIT

package/dist/cjs/generator.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePassphrase = generatePassphrase;
+exports.generatePassword = generatePassword;
+exports.entropyEstimate = entropyEstimate;
+const wordlist_1 = require("./wordlist");
+const utils_1 = require("./utils");
+const strengthDefaults = {
+    medium: { words: 3, symbols: true, digits: 3 },
+    strong: { words: 4, symbols: true, digits: 4 },
+    ultra: { words: 5, symbols: true, digits: 5 }
+};
+function buildDictionary(overrides) {
+    return {
+        adjectives: overrides?.adjectives ?? wordlist_1.adjectives,
+        nouns: overrides?.nouns ?? wordlist_1.nouns,
+        verbs: overrides?.verbs ?? wordlist_1.verbs
+    };
+}
+function chooseWords(dictionary, kinds, unique) {
+    const used = new Set();
+    const output = [];
+    for (const kind of kinds) {
+        const list = kind === "adj" ? dictionary.adjectives : kind === "noun" ? dictionary.nouns : dictionary.verbs;
+        if (list.length === 0) {
+            throw new Error(`Dictionary list for ${kind} is empty`);
+        }
+        let picked = (0, utils_1.randomItem)(list);
+        if (unique) {
+            let attempts = 0;
+            while (used.has(picked) && attempts < 25) {
+                picked = (0, utils_1.randomItem)(list);
+                attempts += 1;
+            }
+        }
+        used.add(picked);
+        output.push(picked);
+    }
+    return output;
+}
+function defaultPattern(words) {
+    const pool = ["adj", "noun", "verb"];
+    const output = [];
+    for (let i = 0; i < words; i += 1) {
+        output.push(pool[i % pool.length]);
+    }
+    return output;
+}
+function generatePassphrase(options = {}) {
+    const defaults = options.strength ? strengthDefaults[options.strength] : strengthDefaults.medium;
+    const wordCount = options.words ?? defaults.words;
+    const useSymbols = options.symbols ?? defaults.symbols;
+    const numbersOption = options.numbers ?? true;
+    const digits = typeof numbersOption === "object" ? numbersOption.digits ?? defaults.digits : defaults.digits;
+    const separator = options.separator ?? "";
+    const uppercaseStyle = options.uppercaseStyle ?? "random";
+    const unique = options.unique ?? true;
+    const dictionary = buildDictionary(options.dictionary);
+    const pattern = options.pattern ?? defaultPattern(wordCount);
+    if (pattern.length !== wordCount) {
+        throw new Error("pattern length must match words");
+    }
+    const words = chooseWords(dictionary, pattern, unique).map((word) => (0, utils_1.applyCase)(word, uppercaseStyle));
+    const parts = [];
+    for (const word of words) {
+        parts.push(word);
+    }
+    if (useSymbols) {
+        const symbols = Array.isArray(useSymbols) ? useSymbols : utils_1.defaultSymbols;
+        parts.push((0, utils_1.randomItem)(symbols));
+    }
+    if (numbersOption) {
+        parts.push(String((0, utils_1.randomNumberByDigits)(digits)));
+    }
+    if (separator) {
+        return parts.join(separator);
+    }
+    return parts.join("");
+}
+function generatePassword(options = {}) {
+    return generatePassphrase(options);
+}
+function entropyEstimate(options = {}) {
+    const defaults = options.strength ? strengthDefaults[options.strength] : strengthDefaults.medium;
+    const wordCount = options.words ?? defaults.words;
+    const useSymbols = options.symbols ?? defaults.symbols;
+    const numbersOption = options.numbers ?? true;
+    const digits = typeof numbersOption === "object" ? numbersOption.digits ?? defaults.digits : defaults.digits;
+    const dictionary = buildDictionary(options.dictionary);
+    const pattern = options.pattern ?? defaultPattern(wordCount);
+    const sizes = pattern.map((kind) => {
+        const list = kind === "adj" ? dictionary.adjectives : kind === "noun" ? dictionary.nouns : dictionary.verbs;
+        return list.length || 1;
+    });
+    const wordSpace = sizes.reduce((acc, size) => acc * size, 1);
+    const symbolSpace = useSymbols ? (Array.isArray(useSymbols) ? useSymbols.length : utils_1.defaultSymbols.length) : 1;
+    const numberSpace = numbersOption ? Math.pow(10, digits) : 1;
+    const total = wordSpace * symbolSpace * numberSpace;
+    return Math.log2(total);
+}

package/dist/cjs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entropyEstimate = exports.generatePassword = exports.generatePassphrase = void 0;
+var generator_1 = require("./generator");
+Object.defineProperty(exports, "generatePassphrase", { enumerable: true, get: function () { return generator_1.generatePassphrase; } });
+Object.defineProperty(exports, "generatePassword", { enumerable: true, get: function () { return generator_1.generatePassword; } });
+Object.defineProperty(exports, "entropyEstimate", { enumerable: true, get: function () { return generator_1.entropyEstimate; } });

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSymbols = void 0;
+exports.secureRandomInt = secureRandomInt;
+exports.randomItem = randomItem;
+exports.randomBool = randomBool;
+exports.applyCase = applyCase;
+exports.randomNumberByDigits = randomNumberByDigits;
+exports.defaultSymbols = ["@", "#", "^", "=", ")", "!", "*", "%"];
+function secureRandomInt(maxExclusive) {
+    if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {
+        throw new Error("maxExclusive must be a positive integer");
+    }
+    const cryptoObj = globalThis.crypto;
+    if (!cryptoObj || typeof cryptoObj.getRandomValues !== "function") {
+        throw new Error("Secure crypto is not available in this environment");
+    }
+    const range = 0x100000000;
+    const limit = range - (range % maxExclusive);
+    const buf = new Uint32Array(1);
+    let value = 0;
+    do {
+        cryptoObj.getRandomValues(buf);
+        value = buf[0];
+    } while (value >= limit);
+    return value % maxExclusive;
+}
+function randomItem(items) {
+    if (items.length === 0) {
+        throw new Error("Cannot choose from an empty list");
+    }
+    return items[secureRandomInt(items.length)];
+}
+function randomBool() {
+    return secureRandomInt(2) === 1;
+}
+function applyCase(word, style) {
+    if (style === "none")
+        return word;
+    if (style === "upper")
+        return word.toUpperCase();
+    if (style === "lower")
+        return word.toLowerCase();
+    if (style === "title")
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    return word
+        .split("")
+        .map((ch) => (randomBool() ? ch.toUpperCase() : ch.toLowerCase()))
+        .join("");
+}
+function randomNumberByDigits(digits) {
+    if (!Number.isInteger(digits) || digits <= 0) {
+        throw new Error("digits must be a positive integer");
+    }
+    const min = Math.pow(10, digits - 1);
+    const max = Math.pow(10, digits) - 1;
+    const span = max - min + 1;
+    return min + secureRandomInt(span);
+}

package/dist/cjs/wordlist.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verbs = exports.nouns = exports.adjectives = void 0;
+exports.adjectives = [
+    // Original
+    "quick", "silent", "brave", "fancy", "eager", "bright",
+    "gentle", "proud", "curious", "steady", "bold", "calm",
+    // Advanced originals
+    "resilient", "ephemeral", "luminous", "tenacious", "serene",
+    "voracious", "ethereal", "stoic", "audacious", "fleeting",
+    "mellifluous", "incisive", "unyielding", "sublime", "transient",
+    "ferocious", "cunning", "reclusive", "radiant", "somber",
+    "deft", "keen", "vigilant", "nimble", "profound",
+    // New: memorial + solemn / meaningful tone
+    "memorial",
+    "immortal",
+    "reverent",
+    "hallowed",
+    "eternal",
+    "venerable",
+    "sacred",
+    "mournful",
+    "remnant",
+    "honored",
+    "legendary",
+    "fabled",
+    "timeless",
+    "perpetual",
+    "solemn",
+    "devoted",
+    "faithful",
+    "righteous",
+    "valiant",
+    "gallant",
+    "exalted",
+    "revered",
+    "venerated",
+    "undying",
+    "everlasting"
+];
+exports.nouns = [
+    // Original
+    "tiger", "goose", "rocket", "mask", "forest", "ocean",
+    "ember", "comet", "cipher", "garden", "river", "mountain",
+    // Advanced originals
+    "phantom", "echo", "horizon", "sentinel", "abyss", "beacon",
+    "shroud", "monolith", "specter", "harbinger", "labyrinth",
+    "oracle", "crucible", "vigil", "rift", "veil", "tempest",
+    "solstice", "requiem", "synapse", "nexus", "axiom", "enigma",
+    "relic", "citadel",
+    // New: memorial + meaningful / legacy words
+    "memorial",
+    "monument",
+    "epitaph",
+    "shrine",
+    "tomb",
+    "grave",
+    "remembrance",
+    "legacy",
+    "heritage",
+    "echo",
+    "keepsake",
+    "memento",
+    "relic",
+    "vestige",
+    "tribute",
+    "offering",
+    "vow",
+    "oath",
+    "covenant",
+    "pillar",
+    "obelisk",
+    "chapel",
+    "sanctum",
+    "archive",
+    "chronicle"
+];
+exports.verbs = [
+    // Original
+    "run", "jump", "build", "mark", "drift", "spark",
+    "forge", "glide", "shift", "trace", "craft", "sprint",
+    // Advanced originals
+    "lunge", "flicker", "shatter", "conceal", "summon", "evade",
+    "descend", "ascend", "sunder", "kindle", "lurk", "surge",
+    "fracture", "unravel", "coalesce", "sever", "ignite", "linger",
+    "plummet", "scatter", "converge", "diverge", "emanate", "sear", "wither",
+    // New: memorial / reverent / legacy actions
+    "honor",
+    "cherish",
+    "enshrine",
+    "lament",
+    "mourn",
+    "remember",
+    "immortalize",
+    "consecrate",
+    "dedicate",
+    "sanctify",
+    "preserve",
+    "bequeath",
+    "endure",
+    "inscribe",
+    "carve",
+    "engrave",
+    "invoke",
+    "recall",
+    "revere",
+    "venerate",
+    "exalt",
+    "glorify",
+    "commemorate",
+    "memorialize",
+    "pay homage"
+];

package/dist/esm/generator.js

@@ -0,0 +1,95 @@
+import { adjectives, nouns, verbs } from "./wordlist";
+import { applyCase, defaultSymbols, randomItem, randomNumberByDigits } from "./utils";
+const strengthDefaults = {
+    medium: { words: 3, symbols: true, digits: 3 },
+    strong: { words: 4, symbols: true, digits: 4 },
+    ultra: { words: 5, symbols: true, digits: 5 }
+};
+function buildDictionary(overrides) {
+    return {
+        adjectives: overrides?.adjectives ?? adjectives,
+        nouns: overrides?.nouns ?? nouns,
+        verbs: overrides?.verbs ?? verbs
+    };
+}
+function chooseWords(dictionary, kinds, unique) {
+    const used = new Set();
+    const output = [];
+    for (const kind of kinds) {
+        const list = kind === "adj" ? dictionary.adjectives : kind === "noun" ? dictionary.nouns : dictionary.verbs;
+        if (list.length === 0) {
+            throw new Error(`Dictionary list for ${kind} is empty`);
+        }
+        let picked = randomItem(list);
+        if (unique) {
+            let attempts = 0;
+            while (used.has(picked) && attempts < 25) {
+                picked = randomItem(list);
+                attempts += 1;
+            }
+        }
+        used.add(picked);
+        output.push(picked);
+    }
+    return output;
+}
+function defaultPattern(words) {
+    const pool = ["adj", "noun", "verb"];
+    const output = [];
+    for (let i = 0; i < words; i += 1) {
+        output.push(pool[i % pool.length]);
+    }
+    return output;
+}
+export function generatePassphrase(options = {}) {
+    const defaults = options.strength ? strengthDefaults[options.strength] : strengthDefaults.medium;
+    const wordCount = options.words ?? defaults.words;
+    const useSymbols = options.symbols ?? defaults.symbols;
+    const numbersOption = options.numbers ?? true;
+    const digits = typeof numbersOption === "object" ? numbersOption.digits ?? defaults.digits : defaults.digits;
+    const separator = options.separator ?? "";
+    const uppercaseStyle = options.uppercaseStyle ?? "random";
+    const unique = options.unique ?? true;
+    const dictionary = buildDictionary(options.dictionary);
+    const pattern = options.pattern ?? defaultPattern(wordCount);
+    if (pattern.length !== wordCount) {
+        throw new Error("pattern length must match words");
+    }
+    const words = chooseWords(dictionary, pattern, unique).map((word) => applyCase(word, uppercaseStyle));
+    const parts = [];
+    for (const word of words) {
+        parts.push(word);
+    }
+    if (useSymbols) {
+        const symbols = Array.isArray(useSymbols) ? useSymbols : defaultSymbols;
+        parts.push(randomItem(symbols));
+    }
+    if (numbersOption) {
+        parts.push(String(randomNumberByDigits(digits)));
+    }
+    if (separator) {
+        return parts.join(separator);
+    }
+    return parts.join("");
+}
+export function generatePassword(options = {}) {
+    return generatePassphrase(options);
+}
+export function entropyEstimate(options = {}) {
+    const defaults = options.strength ? strengthDefaults[options.strength] : strengthDefaults.medium;
+    const wordCount = options.words ?? defaults.words;
+    const useSymbols = options.symbols ?? defaults.symbols;
+    const numbersOption = options.numbers ?? true;
+    const digits = typeof numbersOption === "object" ? numbersOption.digits ?? defaults.digits : defaults.digits;
+    const dictionary = buildDictionary(options.dictionary);
+    const pattern = options.pattern ?? defaultPattern(wordCount);
+    const sizes = pattern.map((kind) => {
+        const list = kind === "adj" ? dictionary.adjectives : kind === "noun" ? dictionary.nouns : dictionary.verbs;
+        return list.length || 1;
+    });
+    const wordSpace = sizes.reduce((acc, size) => acc * size, 1);
+    const symbolSpace = useSymbols ? (Array.isArray(useSymbols) ? useSymbols.length : defaultSymbols.length) : 1;
+    const numberSpace = numbersOption ? Math.pow(10, digits) : 1;
+    const total = wordSpace * symbolSpace * numberSpace;
+    return Math.log2(total);
+}

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { generatePassphrase, generatePassword, entropyEstimate } from "./generator";

package/dist/esm/types.js

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

package/dist/esm/utils.js

@@ -0,0 +1,51 @@
+export const defaultSymbols = ["@", "#", "^", "=", ")", "!", "*", "%"];
+export function secureRandomInt(maxExclusive) {
+    if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {
+        throw new Error("maxExclusive must be a positive integer");
+    }
+    const cryptoObj = globalThis.crypto;
+    if (!cryptoObj || typeof cryptoObj.getRandomValues !== "function") {
+        throw new Error("Secure crypto is not available in this environment");
+    }
+    const range = 0x100000000;
+    const limit = range - (range % maxExclusive);
+    const buf = new Uint32Array(1);
+    let value = 0;
+    do {
+        cryptoObj.getRandomValues(buf);
+        value = buf[0];
+    } while (value >= limit);
+    return value % maxExclusive;
+}
+export function randomItem(items) {
+    if (items.length === 0) {
+        throw new Error("Cannot choose from an empty list");
+    }
+    return items[secureRandomInt(items.length)];
+}
+export function randomBool() {
+    return secureRandomInt(2) === 1;
+}
+export function applyCase(word, style) {
+    if (style === "none")
+        return word;
+    if (style === "upper")
+        return word.toUpperCase();
+    if (style === "lower")
+        return word.toLowerCase();
+    if (style === "title")
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    return word
+        .split("")
+        .map((ch) => (randomBool() ? ch.toUpperCase() : ch.toLowerCase()))
+        .join("");
+}
+export function randomNumberByDigits(digits) {
+    if (!Number.isInteger(digits) || digits <= 0) {
+        throw new Error("digits must be a positive integer");
+    }
+    const min = Math.pow(10, digits - 1);
+    const max = Math.pow(10, digits) - 1;
+    const span = max - min + 1;
+    return min + secureRandomInt(span);
+}

package/dist/esm/wordlist.js

@@ -0,0 +1,110 @@
+export const adjectives = [
+    // Original
+    "quick", "silent", "brave", "fancy", "eager", "bright",
+    "gentle", "proud", "curious", "steady", "bold", "calm",
+    // Advanced originals
+    "resilient", "ephemeral", "luminous", "tenacious", "serene",
+    "voracious", "ethereal", "stoic", "audacious", "fleeting",
+    "mellifluous", "incisive", "unyielding", "sublime", "transient",
+    "ferocious", "cunning", "reclusive", "radiant", "somber",
+    "deft", "keen", "vigilant", "nimble", "profound",
+    // New: memorial + solemn / meaningful tone
+    "memorial",
+    "immortal",
+    "reverent",
+    "hallowed",
+    "eternal",
+    "venerable",
+    "sacred",
+    "mournful",
+    "remnant",
+    "honored",
+    "legendary",
+    "fabled",
+    "timeless",
+    "perpetual",
+    "solemn",
+    "devoted",
+    "faithful",
+    "righteous",
+    "valiant",
+    "gallant",
+    "exalted",
+    "revered",
+    "venerated",
+    "undying",
+    "everlasting"
+];
+export const nouns = [
+    // Original
+    "tiger", "goose", "rocket", "mask", "forest", "ocean",
+    "ember", "comet", "cipher", "garden", "river", "mountain",
+    // Advanced originals
+    "phantom", "echo", "horizon", "sentinel", "abyss", "beacon",
+    "shroud", "monolith", "specter", "harbinger", "labyrinth",
+    "oracle", "crucible", "vigil", "rift", "veil", "tempest",
+    "solstice", "requiem", "synapse", "nexus", "axiom", "enigma",
+    "relic", "citadel",
+    // New: memorial + meaningful / legacy words
+    "memorial",
+    "monument",
+    "epitaph",
+    "shrine",
+    "tomb",
+    "grave",
+    "remembrance",
+    "legacy",
+    "heritage",
+    "echo",
+    "keepsake",
+    "memento",
+    "relic",
+    "vestige",
+    "tribute",
+    "offering",
+    "vow",
+    "oath",
+    "covenant",
+    "pillar",
+    "obelisk",
+    "chapel",
+    "sanctum",
+    "archive",
+    "chronicle"
+];
+export const verbs = [
+    // Original
+    "run", "jump", "build", "mark", "drift", "spark",
+    "forge", "glide", "shift", "trace", "craft", "sprint",
+    // Advanced originals
+    "lunge", "flicker", "shatter", "conceal", "summon", "evade",
+    "descend", "ascend", "sunder", "kindle", "lurk", "surge",
+    "fracture", "unravel", "coalesce", "sever", "ignite", "linger",
+    "plummet", "scatter", "converge", "diverge", "emanate", "sear", "wither",
+    // New: memorial / reverent / legacy actions
+    "honor",
+    "cherish",
+    "enshrine",
+    "lament",
+    "mourn",
+    "remember",
+    "immortalize",
+    "consecrate",
+    "dedicate",
+    "sanctify",
+    "preserve",
+    "bequeath",
+    "endure",
+    "inscribe",
+    "carve",
+    "engrave",
+    "invoke",
+    "recall",
+    "revere",
+    "venerate",
+    "exalt",
+    "glorify",
+    "commemorate",
+    "memorialize",
+    "pay homage"
+];

package/dist/generator.d.ts

@@ -0,0 +1,4 @@
+import type { GenerateOptions } from "./types";
+export declare function generatePassphrase(options?: GenerateOptions): string;
+export declare function generatePassword(options?: GenerateOptions): string;
+export declare function entropyEstimate(options?: GenerateOptions): number;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { generatePassphrase, generatePassword, entropyEstimate } from "./generator";
+export type { GenerateOptions, Dictionary, UppercaseStyle, Strength, WordKind } from "./types";

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export type UppercaseStyle = "none" | "random" | "title" | "upper" | "lower";
+export type Strength = "medium" | "strong" | "ultra";
+export type WordKind = "adj" | "noun" | "verb";
+export interface Dictionary {
+    adjectives: string[];
+    nouns: string[];
+    verbs: string[];
+}
+export interface GenerateOptions {
+    words?: number;
+    numbers?: boolean | {
+        digits?: number;
+    };
+    symbols?: boolean | string[];
+    uppercaseStyle?: UppercaseStyle;
+    separator?: string;
+    unique?: boolean;
+    strength?: Strength;
+    pattern?: WordKind[];
+    dictionary?: Partial<Dictionary>;
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultSymbols: string[];
+export declare function secureRandomInt(maxExclusive: number): number;
+export declare function randomItem<T>(items: T[]): T;
+export declare function randomBool(): boolean;
+export declare function applyCase(word: string, style: "none" | "random" | "title" | "upper" | "lower"): string;
+export declare function randomNumberByDigits(digits: number): number;

package/dist/wordlist.d.ts

@@ -0,0 +1,3 @@
+export declare const adjectives: string[];
+export declare const nouns: string[];
+export declare const verbs: string[];

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "smart-passphrase",
+  "version": "1.0.0",
+  "description": "Memorable, secure passphrase generator for web and Node.",
+  "license": "MIT",
+  "author": "Ayush Solanki <ayushsolanki2901@gmail.com> (https://github.com/ayushsolanki29)",
+  "type": "module",
+
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ayushsolanki29/smart-passphrase"
+  },
+
+  "keywords": [
+    "password",
+    "passphrase",
+    "generator",
+    "security",
+    "typescript"
+  ],
+
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+
+  "files": ["dist"],
+  "sideEffects": false,
+
+  "scripts": {
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build": "npm run build:esm && npm run build:cjs"
+  },
+
+  "devDependencies": {
+    "typescript": "^5.5.4"
+  }
+}