xypriss-security 2.0.9 → 2.1.1

package/dist/src/core/PasswordManager.js

@@ -0,0 +1,478 @@
+"use strict";
+/***************************************************************************
+ * XyPriss Security - Advanced Hyper-Modular Security Framework
+ *
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
+ * @license Nehonix Open Source License (NOSL)
+ *
+ * Copyright (c) 2025 NEHONIX. All rights reserved.
+ ****************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasswordManager = void 0;
+const crypto_1 = require("crypto");
+const path_1 = require("path");
+const Password_1 = require("./Password");
+const Random_1 = require("./Random");
+const PasswordMDict_1 = require("../mods/PasswordMDict");
+// ─── PasswordManager ──────────────────────────────────────────────────────────
+/***************************************************************************
+ * ### PasswordManager
+ *
+ * A configurable, instance-based password manager.
+ * Unlike the static `Password` class, `PasswordManager` is instantiated
+ * once with all options pre-configured, so callers only need to pass
+ * the raw password string at call time.
+ *
+ * This is the recommended pattern for large-scale projects:
+ * configure once in a dedicated file, export the instance, and reuse
+ * everywhere without repeating options.
+ *
+ * @example
+ * // config/security.ts
+ * export const passwords = new PasswordManager({
+ *   algorithm: "argon2id",
+ *   memoryCost: 65536,
+ *   parallelism: 4,
+ *   iterations: 3,
+ *   pepper: process.env.PASSWORD_PEPPER,
+ * });
+ *
+ * // anywhere in the app:
+ * const hash       = await passwords.hash("user-raw-password");
+ * const valid      = await passwords.verify("user-raw-password", hash);
+ * const temp       = passwords.generate({ length: 24, symbols: true });
+ * const passphrase = passwords.generatePassphrase({ wordCount: 5 });
+ * const pin        = passwords.generatePin(6);
+ * const info       = passwords.strength("MyP@ss1!");
+ * const breach     = await passwords.isBreached("hunter2");
+ * const stale      = passwords.needsRehash(storedHash);
+ */
+class PasswordManager {
+    constructor(options = {}) {
+        this.algo = (options.algorithm ?? "argon2id").toLowerCase();
+        this.memoryCost = options.memoryCost ?? 65536; // 64 MiB
+        this.iterations = options.iterations ?? 3;
+        this.parallelism = options.parallelism ?? 4;
+        this.pepper = options.pepper;
+    }
+    // ─── Hashing ───────────────────────────────────────────────────────────────
+    /**
+     * Hashes a password using the instance's pre-configured options.
+     *
+     * @param password - The plain-text password to hash.
+     * @param overrides - Optional per-call overrides for any constructor option.
+     * @returns The encoded hash string, ready to be stored.
+     */
+    async hash(password, overrides = {}) {
+        const pepper = overrides.pepper ?? this.pepper;
+        const finalPassword = pepper ? password + pepper : password;
+        return Password_1.Password.hash(finalPassword, {
+            algorithm: overrides.algorithm ?? this.algo,
+            memoryCost: overrides.memoryCost ?? this.memoryCost,
+            iterations: overrides.iterations ?? this.iterations,
+            parallelism: overrides.parallelism ?? this.parallelism,
+        });
+    }
+    /**
+     * Verifies a plain-text password against a stored hash.
+     *
+     * @param password - The password to verify.
+     * @param hash - The stored hash to compare against.
+     * @param overrides - Optional per-call override for the pepper.
+     * @returns `true` if the password matches the hash, `false` otherwise.
+     */
+    async verify(password, hash, overrides = {}) {
+        const pepper = overrides.pepper ?? this.pepper;
+        const finalPassword = pepper ? password + pepper : password;
+        return Password_1.Password.verify(finalPassword, hash);
+    }
+    // ─── Generation ────────────────────────────────────────────────────────────
+    /**
+     * Generates a cryptographically secure random password matching the given
+     * criteria, with **guaranteed character-type coverage**.
+     *
+     * Security properties:
+     * - Every enabled character type appears **at least once** in the output.
+     * - `extra` characters are **injected at cryptographically random positions**
+     *   rather than appended, ensuring they don't cluster at the end.
+     * - The final array is **Fisher-Yates shuffled** via `Random.Int` to remove
+     *   any positional bias introduced during construction.
+     * - `length` is clamped to [8, 512] to prevent misuse.
+     * - Throws `RangeError` if no character type is enabled (empty charset).
+     *
+     * @param options - Character set and length configuration.
+     * @returns A plain-text randomly generated password string.
+     *
+     * @example
+     * const pwd = passwords.generate({ length: 24, symbols: true });
+     */
+    generate(options = {}) {
+        const { uppercase = true, lowercase = true, numbers = true, symbols = true, excludeSimilar = false, extra = "", } = options;
+        // ── 1. Clamp & validate length ──────────────────────────────────────────
+        const length = Math.min(PasswordMDict_1.MAX_GENERATE_LENGTH, Math.max(PasswordMDict_1.MIN_GENERATE_LENGTH, Math.floor(options.length ?? 20)));
+        // ── 2. Build charset ────────────────────────────────────────────────────
+        let charset = "";
+        const mandatory = []; // at least one char from each active set
+        const addSet = (chars, enabled) => {
+            if (!enabled)
+                return;
+            const cleaned = excludeSimilar
+                ? chars.replace(PasswordMDict_1.CHARSETS.similarChars, "")
+                : chars;
+            if (cleaned.length === 0)
+                return;
+            charset += cleaned;
+            // Reserve one guaranteed character from this set
+            mandatory.push(cleaned[Random_1.Random.Int(0, cleaned.length)]);
+        };
+        addSet(PasswordMDict_1.CHARSETS.lowercase, lowercase);
+        addSet(PasswordMDict_1.CHARSETS.uppercase, uppercase);
+        addSet(PasswordMDict_1.CHARSETS.numbers, numbers);
+        addSet(PasswordMDict_1.CHARSETS.symbols, symbols);
+        if (charset.length === 0) {
+            throw new RangeError("PasswordManager.generate: no character types enabled — charset is empty.");
+        }
+        // Guarantee at least one char per extra string (injected, not appended)
+        if (extra) {
+            for (const ch of extra) {
+                if (!charset.includes(ch))
+                    charset += ch;
+                mandatory.push(ch);
+            }
+        }
+        // ── 3. Guard: mandatory set cannot exceed requested length ───────────────
+        if (mandatory.length > length) {
+            throw new RangeError(`PasswordManager.generate: requested length (${length}) is too short ` +
+                `to satisfy all enabled character types (need at least ${mandatory.length}).`);
+        }
+        // ── 4. Fill remaining slots from full charset ────────────────────────────
+        const arr = [...mandatory];
+        const remaining = length - arr.length;
+        for (let i = 0; i < remaining; i++) {
+            arr.push(charset[Random_1.Random.Int(0, charset.length)]);
+        }
+        // ── 5. Fisher-Yates shuffle (crypto-safe via Random.Int) ─────────────────
+        for (let i = arr.length - 1; i > 0; i--) {
+            const j = Random_1.Random.Int(0, i + 1);
+            [arr[i], arr[j]] = [arr[j], arr[i]];
+        }
+        return arr.join("");
+    }
+    // ─── Passphrase Generation ─────────────────────────────────────────────────
+    /**
+     * Generates a **memorable, high-entropy passphrase** using a curated
+     * 256-word list (similar to Diceware / EFF methodology).
+     *
+     * Entropy: `log2(256^wordCount)` = `8 * wordCount` bits minimum.
+     * With 5 words: ~40 bits base + number suffix ≈ 53 bits total.
+     * With 6 words: ~48 bits base + number suffix ≈ 61 bits total.
+     *
+     * Security note: word selection uses `Random.Int` which must be backed
+     * by a CSPRNG (e.g. `crypto.randomInt`).
+     *
+     * @param options - Passphrase configuration.
+     * @returns A plain-text passphrase string.
+     *
+     * @example
+     * passwords.generatePassphrase({ wordCount: 5, separator: "-" });
+     * // → "Bold-Cave-Iron-Jump-Warm-4827"
+     */
+    generatePassphrase(options = {}) {
+        const { wordCount = 5, separator = "-", capitalize = true, appendNumbers = true, variant = "large", dir, filePath, allowFallback = "silent", } = options;
+        if (wordCount < 3 || wordCount > 20) {
+            throw new RangeError("PasswordManager.generatePassphrase: wordCount must be between 3 and 20.");
+        }
+        // Resolve the bundled mods dir relative to this compiled file
+        // dist/src/core/PasswordManager.js → ../../mods  (production)
+        // src/core/PasswordManager.ts      → ../mods      (dev/bun direct)
+        const modsDir = dir ??
+            (0, path_1.join)(__dirname, "..", "mods") +
+                // ts-source fallback: if __dirname ends with /core, ../mods resolves correctly
+                "";
+        const wordlist = (0, PasswordMDict_1.getWordlist)({
+            dir: modsDir,
+            variant,
+            filePath,
+            allowFallback,
+        });
+        const words = [];
+        for (let i = 0; i < wordCount; i++) {
+            let word = wordlist[Random_1.Random.Int(0, wordlist.length)];
+            if (capitalize) {
+                word = word.charAt(0).toUpperCase() + word.slice(1);
+            }
+            words.push(word);
+        }
+        if (appendNumbers) {
+            // 4-digit suffix adds ~13 extra bits of entropy
+            const suffix = String(Random_1.Random.Int(1000, 9999));
+            words.push(suffix);
+        }
+        return words.join(separator);
+    }
+    // ─── PIN Generation ────────────────────────────────────────────────────────
+    /**
+     * Generates a cryptographically secure numeric PIN.
+     *
+     * Each digit is drawn independently from the full [0-9] range.
+     * The PIN is **zero-padded** to the requested length and returned as a
+     * string to preserve leading zeros (e.g. "0472").
+     *
+     * @param length - Number of digits. Must be between 4 and 32. @default 6
+     * @returns A plain-text numeric PIN string.
+     *
+     * @example
+     * passwords.generatePin(6); // → "047291"
+     */
+    generatePin(length = 6) {
+        if (!Number.isInteger(length) || length < 4 || length > 32) {
+            throw new RangeError("PasswordManager.generatePin: length must be an integer between 4 and 32.");
+        }
+        const digits = [];
+        for (let i = 0; i < length; i++) {
+            digits.push(String(Random_1.Random.Int(0, 10)));
+        }
+        return digits.join("");
+    }
+    // ─── Strength Analysis ─────────────────────────────────────────────────────
+    /**
+     * Evaluates the strength of a password and returns a detailed report.
+     *
+     * The score is computed from multiple orthogonal criteria:
+     * - Length (up to 30 points)
+     * - Character variety (up to 50 points)
+     * - Absence of repetitions and sequences (up to 20 points deducted)
+     *
+     * @param password - The password to evaluate.
+     * @returns A `PasswordStrengthResult` with score, label, and actionable suggestions.
+     *
+     * @example
+     * const info = passwords.strength("MyP@ssw0rd!");
+     * console.log(info.score, info.label); // 82 "strong"
+     */
+    strength(password) {
+        const suggestions = [];
+        // ── Characteristic flags ────────────────────────────────────────────────
+        const hasUppercase = /[A-Z]/.test(password);
+        const hasLowercase = /[a-z]/.test(password);
+        const hasNumbers = /[0-9]/.test(password);
+        const hasSymbols = /[^A-Za-z0-9]/.test(password);
+        const hasRepeats = /(.)\1{2,}/.test(password);
+        const hasSequences = /(abc|bcd|cde|def|efg|fgh|ghi|hij|ijk|jkl|klm|lmn|mno|nop|opq|pqr|qrs|rst|stu|tuv|uvw|vwx|wxy|xyz|012|123|234|345|456|567|678|789)/i.test(password);
+        // ── Length score (0-30) ─────────────────────────────────────────────────
+        const len = password.length;
+        let lengthScore = 0;
+        if (len >= 8)
+            lengthScore += 10;
+        if (len >= 12)
+            lengthScore += 10;
+        if (len >= 16)
+            lengthScore += 5;
+        if (len >= 20)
+            lengthScore += 5;
+        // ── Variety score (0-50) ────────────────────────────────────────────────
+        let varietyScore = 0;
+        if (hasLowercase)
+            varietyScore += 10;
+        if (hasUppercase)
+            varietyScore += 10;
+        if (hasNumbers)
+            varietyScore += 10;
+        if (hasSymbols)
+            varietyScore += 15;
+        if (hasLowercase && hasUppercase && hasNumbers && hasSymbols)
+            varietyScore += 5;
+        // ── Penalty score (0..20 subtracted) ───────────────────────────────────
+        let penaltyScore = 0;
+        if (hasRepeats)
+            penaltyScore += 10;
+        if (hasSequences)
+            penaltyScore += 10;
+        // ── Entropy estimation (bits) ───────────────────────────────────────────
+        let charsetSize = 0;
+        if (hasLowercase)
+            charsetSize += 26;
+        if (hasUppercase)
+            charsetSize += 26;
+        if (hasNumbers)
+            charsetSize += 10;
+        if (hasSymbols)
+            charsetSize += 32;
+        const entropy = charsetSize > 0 ? Math.round(len * Math.log2(charsetSize)) : 0;
+        const score = Math.max(0, Math.min(100, lengthScore + varietyScore - penaltyScore));
+        // ── Suggestions ────────────────────────────────────────────────────────
+        if (len < 8)
+            suggestions.push("Use at least 8 characters.");
+        if (len < 12)
+            suggestions.push("A length of 12 or more is recommended.");
+        if (len < 16)
+            suggestions.push("Aim for 16+ characters for high-security contexts.");
+        if (!hasUppercase)
+            suggestions.push("Add uppercase letters (A-Z).");
+        if (!hasLowercase)
+            suggestions.push("Add lowercase letters (a-z).");
+        if (!hasNumbers)
+            suggestions.push("Include at least one digit (0-9).");
+        if (!hasSymbols)
+            suggestions.push("Include at least one special character (!@#$%...).");
+        if (hasRepeats)
+            suggestions.push("Avoid repeating characters (e.g. 'aaa').");
+        if (hasSequences)
+            suggestions.push("Avoid common sequences (e.g. '123', 'abc').");
+        // ── Label ──────────────────────────────────────────────────────────────
+        let label;
+        if (score < 20)
+            label = "very-weak";
+        else if (score < 40)
+            label = "weak";
+        else if (score < 60)
+            label = "fair";
+        else if (score < 80)
+            label = "strong";
+        else
+            label = "very-strong";
+        return {
+            score,
+            label,
+            suggestions,
+            analysis: {
+                length: len,
+                hasUppercase,
+                hasLowercase,
+                hasNumbers,
+                hasSymbols,
+                hasRepeats,
+                hasSequences,
+                entropy,
+            },
+        };
+    }
+    // ─── Breach Check ──────────────────────────────────────────────────────────
+    /**
+     * Checks whether a password has appeared in a publicly known data breach
+     * using the **HaveIBeenPwned Pwned Passwords API v3** with **k-anonymity**.
+     *
+     * The full password is **never transmitted**. Only the first 5 characters of
+     * its SHA-1 hex digest are sent over the network; the remainder of the
+     * matching is performed locally.
+     *
+     * @param password - The plain-text password to check.
+     * @returns A `BreachCheckResult` indicating breach status and occurrence count.
+     * @throws If the network request fails or returns an unexpected status code.
+     *
+     * @example
+     * const result = await passwords.isBreached("hunter2");
+     * if (result.breached) {
+     *   console.warn(`Password found ${result.occurrences} times in breach databases.`);
+     * }
+     */
+    async isBreached(password) {
+        const sha1 = (0, crypto_1.createHash)("sha1")
+            .update(password)
+            .digest("hex")
+            .toUpperCase();
+        const prefix = sha1.slice(0, 5);
+        const suffix = sha1.slice(5);
+        const response = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`, {
+            headers: {
+                // Padding header reduces response-size side-channel leakage
+                "Add-Padding": "true",
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`PasswordManager.isBreached: HIBP API returned HTTP ${response.status}.`);
+        }
+        const body = await response.text();
+        // Each line: "<SUFFIX>:<COUNT>" or "<SUFFIX>:0" (padding entries)
+        for (const line of body.split("\r\n")) {
+            const [hashSuffix, countStr] = line.split(":");
+            if (hashSuffix === suffix) {
+                const occurrences = parseInt(countStr, 10);
+                return { breached: occurrences > 0, occurrences };
+            }
+        }
+        return { breached: false, occurrences: 0 };
+    }
+    // ─── Rehash Detection ──────────────────────────────────────────────────────
+    /**
+     * Determines whether a stored hash was produced with weaker parameters than
+     * the instance's current configuration (e.g. after a security upgrade).
+     *
+     * Supports Argon2id hash strings in the PHC string format:
+     * `$argon2id$v=19$m=<mem>,t=<iter>,p=<par>$<salt>$<hash>`
+     *
+     * For other algorithms, returns `false` (no opinion) so the caller can
+     * decide on a case-by-case basis.
+     *
+     * @param hash - The stored hash string to inspect.
+     * @returns `true` if the hash should be re-hashed on next successful login.
+     *
+     * @example
+     * if (passwords.needsRehash(user.passwordHash)) {
+     *   user.passwordHash = await passwords.hash(rawPassword);
+     *   await user.save();
+     * }
+     */
+    needsRehash(hash) {
+        if (!hash.startsWith("$argon2id$"))
+            return false;
+        // Parse PHC format: $argon2id$v=19$m=65536,t=3,p=4$...
+        const paramsMatch = hash.match(/\$m=(\d+),t=(\d+),p=(\d+)\$/);
+        if (!paramsMatch)
+            return true; // malformed → force rehash
+        const [, m, t, p] = paramsMatch.map(Number);
+        return m < this.memoryCost || t < this.iterations || p < this.parallelism;
+    }
+    // ─── Input Sanitization ────────────────────────────────────────────────────
+    /**
+     * Validates and normalizes a raw password string before hashing.
+     *
+     * Checks performed:
+     * - Not empty or whitespace-only.
+     * - Minimum length of 8 characters.
+     * - Maximum length of 1024 characters (DoS guard against bcrypt-style
+     *   long-password attacks on other algorithms).
+     * - Unicode NFC normalization (prevents homoglyph bypass attacks).
+     *
+     * @param password - The raw password string from user input.
+     * @returns The NFC-normalized password, ready for hashing.
+     * @throws `TypeError` if the input is not a string.
+     * @throws `RangeError` if the password fails length validation.
+     *
+     * @example
+     * const normalized = passwords.sanitizeInput(req.body.password);
+     * const hash = await passwords.hash(normalized);
+     */
+    sanitizeInput(password) {
+        if (typeof password !== "string") {
+            throw new TypeError("PasswordManager.sanitizeInput: password must be a string.");
+        }
+        const trimmed = password.trim();
+        if (trimmed.length === 0) {
+            throw new RangeError("PasswordManager.sanitizeInput: password must not be empty.");
+        }
+        if (trimmed.length < 8) {
+            throw new RangeError("PasswordManager.sanitizeInput: password must be at least 8 characters long.");
+        }
+        if (trimmed.length > 1024) {
+            throw new RangeError("PasswordManager.sanitizeInput: password exceeds the maximum allowed length (1024).");
+        }
+        // NFC normalization: prevents ā (U+0101) vs a + combining macron attacks
+        return trimmed.normalize("NFC");
+    }
+    // ─── Utilities ─────────────────────────────────────────────────────────────
+    /**
+     * Returns a summary of the instance's current configuration.
+     * The `pepper` is intentionally omitted from the output.
+     */
+    getConfig() {
+        return {
+            algorithm: this.algo,
+            memoryCost: this.memoryCost,
+            iterations: this.iterations,
+            parallelism: this.parallelism,
+        };
+    }
+}
+exports.PasswordManager = PasswordManager;
+//# sourceMappingURL=PasswordManager.js.map

package/dist/src/core/PasswordManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PasswordManager.js","sourceRoot":"","sources":["../../../src/core/PasswordManager.ts"],"names":[],"mappings":"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"}

package/dist/src/core/SecureBuffer.d.ts

@@ -4,7 +4,7 @@
  * An enhanced Uint8Array that provides familiar encoding methods
  * similar to Node.js Buffer, optimized for security operations.
  *
- * @author NEHONIX (iDevo - https://github.com/iDevo-ll)
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
  * @license Nehonix Open Source License (NOSL)
  ****************************************************************************/
 import { __strl__ } from "strulink";

package/dist/src/core/SecureBuffer.js

@@ -5,7 +5,7 @@
  * An enhanced Uint8Array that provides familiar encoding methods
  * similar to Node.js Buffer, optimized for security operations.
  *
- * @author NEHONIX (iDevo - https://github.com/iDevo-ll)
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
  * @license Nehonix Open Source License (NOSL)
  ****************************************************************************/
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/index.d.ts

@@ -4,18 +4,19 @@
  * Provides high-level security classes (Hash, Random, Password, XyPrissSecurity)
  * that wrap the high-performance Go-based core bridge.
  *
- * @author NEHONIX (iDevo - https://github.com/iDevo-ll)
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
  * @license Nehonix Open Source License (NOSL)
  ****************************************************************************/
 export * from "./Hash";
 export * from "./Random";
 export * from "./Password";
+export * from "./PasswordManager";
 export * from "./XyPrissSecurity";
 export * from "./SecureBuffer";
 export * from "./keys";
 export * from "./bridge";
 export { XyPrissSecurity as XSec } from "./XyPrissSecurity";
-export { Password as pm } from "./Password";
+export { PasswordManager as pm } from "./PasswordManager";
 import { Hash } from "./Hash";
 import { Random } from "./Random";
 import { XyPrissSecurity } from "./XyPrissSecurity";

package/dist/src/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;8EAQ8E;AAE9E,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AAEzB,OAAO,EAAE,eAAe,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;GAKG;AACH,qBAAa,MAAM;IACjB,oDAAoD;IACpD,gBAAuB,IAAI,cAAQ;IACnC,mEAAmE;IACnE,gBAAuB,MAAM,gBAAU;IACvC,+BAA+B;IAC/B,gBAAuB,MAAM,gBAAU;IACvC,6DAA6D;IAC7D,gBAAuB,IAAI,yBAAmB;CAC/C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;8EAQ8E;AAE9E,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AAEzB,OAAO,EAAE,eAAe,IAAI,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,eAAe,IAAI,EAAE,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;GAKG;AACH,qBAAa,MAAM;IACjB,oDAAoD;IACpD,gBAAuB,IAAI,cAAQ;IACnC,mEAAmE;IACnE,gBAAuB,MAAM,gBAAU;IACvC,+BAA+B;IAC/B,gBAAuB,MAAM,gBAAU;IACvC,6DAA6D;IAC7D,gBAAuB,IAAI,yBAAmB;CAC/C"}

package/dist/src/core/index.js

@@ -5,7 +5,7 @@
  * Provides high-level security classes (Hash, Random, Password, XyPrissSecurity)
  * that wrap the high-performance Go-based core bridge.
  *
- * @author NEHONIX (iDevo - https://github.com/iDevo-ll)
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
  * @license Nehonix Open Source License (NOSL)
  ****************************************************************************/
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -27,14 +27,15 @@ exports.Cipher = exports.pm = exports.XSec = void 0;
 __exportStar(require("./Hash"), exports);
 __exportStar(require("./Random"), exports);
 __exportStar(require("./Password"), exports);
+__exportStar(require("./PasswordManager"), exports);
 __exportStar(require("./XyPrissSecurity"), exports);
 __exportStar(require("./SecureBuffer"), exports);
 __exportStar(require("./keys"), exports);
 __exportStar(require("./bridge"), exports);
 var XyPrissSecurity_1 = require("./XyPrissSecurity"); // Alias for XyPrissSecurity
 Object.defineProperty(exports, "XSec", { enumerable: true, get: function () { return XyPrissSecurity_1.XyPrissSecurity; } });
-var Password_1 = require("./Password"); // Alias for Password
-Object.defineProperty(exports, "pm", { enumerable: true, get: function () { return Password_1.Password; } });
+var PasswordManager_1 = require("./PasswordManager"); // Alias for PasswordManager
+Object.defineProperty(exports, "pm", { enumerable: true, get: function () { return PasswordManager_1.PasswordManager; } });
 const Hash_1 = require("./Hash");
 const Random_1 = require("./Random");
 const XyPrissSecurity_2 = require("./XyPrissSecurity");

package/dist/src/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;8EAQ8E;;;;;;;;;;;;;;;;;AAE9E,yCAAuB;AACvB,2CAAyB;AACzB,6CAA2B;AAC3B,oDAAkC;AAClC,iDAA+B;AAC/B,yCAAuB;AACvB,2CAAyB;AAEzB,qDAA4D,CAAC,4BAA4B;AAAhF,uGAAA,eAAe,OAAQ;AAChC,uCAA4C,CAAC,qBAAqB;AAAzD,8FAAA,QAAQ,OAAM;AAEvB,iCAA8B;AAC9B,qCAAkC;AAClC,uDAAoD;AAEpD;;;;;GAKG;AACH,MAAa,MAAM;;AAAnB,wBASC;AARC,oDAAoD;AAC7B,WAAI,GAAG,WAAI,CAAC;AACnC,mEAAmE;AAC5C,aAAM,GAAG,eAAM,CAAC;AACvC,+BAA+B;AACR,aAAM,GAAG,eAAM,CAAC;AACvC,6DAA6D;AACtC,WAAI,GAAG,iCAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;8EAQ8E;;;;;;;;;;;;;;;;;AAE9E,yCAAuB;AACvB,2CAAyB;AACzB,6CAA2B;AAC3B,oDAAkC;AAClC,oDAAkC;AAClC,iDAA+B;AAC/B,yCAAuB;AACvB,2CAAyB;AAEzB,qDAA4D,CAAC,4BAA4B;AAAhF,uGAAA,eAAe,OAAQ;AAChC,qDAA0D,CAAC,4BAA4B;AAA9E,qGAAA,eAAe,OAAM;AAE9B,iCAA8B;AAC9B,qCAAkC;AAClC,uDAAoD;AAEpD;;;;;GAKG;AACH,MAAa,MAAM;;AAAnB,wBASC;AARC,oDAAoD;AAC7B,WAAI,GAAG,WAAI,CAAC;AACnC,mEAAmE;AAC5C,aAAM,GAAG,eAAM,CAAC;AACvC,+BAA+B;AACR,aAAM,GAAG,eAAM,CAAC;AACvC,6DAA6D;AACtC,WAAI,GAAG,iCAAe,CAAC"}

package/dist/src/index.d.ts

@@ -1,12 +1,12 @@
 /***************************************************************************
  * XyPriss Security - Advanced Hyper-Modular Security Framework
  *
- * @author NEHONIX (iDevo - https://github.com/iDevo-ll)
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
  * @license Nehonix Open Source License (NOSL)
  *
  * Copyright (c) 2025 NEHONIX. All rights reserved.
  ****************************************************************************/
-import { Password } from "./core/Password";
+export { Password } from "./core/Password";
 /**
  * # XyPriss Security
  *
@@ -18,5 +18,5 @@ export * from "./utils/index";
 export * from "./components/encryption/index";
 export * from "./components/serializer";
 export * from "./components/cache/SecureCacheAdapter";
-export declare const PasswordManager: typeof Password;
+export { CHARSETS, MIN_GENERATE_LENGTH, MAX_GENERATE_LENGTH, getWordlist, } from "./mods/PasswordMDict";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;8EAO8E;AAE9E,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;;;GAIG;AAGH,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,eAAe,CAAC;AAC9B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uCAAuC,CAAC;AAEtD,eAAO,MAAM,eAAe,iBAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;8EAO8E;AAE9E,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C;;;;GAIG;AAGH,cAAc,cAAc,CAAC;AAG7B,cAAc,oBAAoB,CAAC;AAGnC,cAAc,eAAe,CAAC;AAC9B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uCAAuC,CAAC;AAEtD,OAAO,EACL,QAAQ,EACR,mBAAmB,EACnB,mBAAmB,EACnB,WAAW,GACZ,MAAM,sBAAsB,CAAC"}

package/dist/src/index.js

@@ -2,7 +2,7 @@
 /***************************************************************************
  * XyPriss Security - Advanced Hyper-Modular Security Framework
  *
- * @author NEHONIX (iDevo - https://github.com/iDevo-ll)
+ * @author NEHONIX (Nehonix-Team - https://github.com/Nehonix-Team)
  * @license Nehonix Open Source License (NOSL)
  *
  * Copyright (c) 2025 NEHONIX. All rights reserved.
@@ -22,8 +22,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PasswordManager = void 0;
-const Password_1 = require("./core/Password");
+exports.getWordlist = exports.MAX_GENERATE_LENGTH = exports.MIN_GENERATE_LENGTH = exports.CHARSETS = exports.Password = void 0;
+var Password_1 = require("./core/Password");
+Object.defineProperty(exports, "Password", { enumerable: true, get: function () { return Password_1.Password; } });
 /**
  * # XyPriss Security
  *
@@ -38,6 +39,9 @@ __exportStar(require("./utils/index"), exports);
 __exportStar(require("./components/encryption/index"), exports);
 __exportStar(require("./components/serializer"), exports);
 __exportStar(require("./components/cache/SecureCacheAdapter"), exports);
-// pour compatibilité avec les autres
-exports.PasswordManager = Password_1.Password;
+var PasswordMDict_1 = require("./mods/PasswordMDict");
+Object.defineProperty(exports, "CHARSETS", { enumerable: true, get: function () { return PasswordMDict_1.CHARSETS; } });
+Object.defineProperty(exports, "MIN_GENERATE_LENGTH", { enumerable: true, get: function () { return PasswordMDict_1.MIN_GENERATE_LENGTH; } });
+Object.defineProperty(exports, "MAX_GENERATE_LENGTH", { enumerable: true, get: function () { return PasswordMDict_1.MAX_GENERATE_LENGTH; } });
+Object.defineProperty(exports, "getWordlist", { enumerable: true, get: function () { return PasswordMDict_1.getWordlist; } });
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;8EAO8E;;;;;;;;;;;;;;;;;AAE9E,8CAA2C;AAE3C;;;;GAIG;AAEH,yDAAyD;AACzD,+CAA6B,CAAC,6CAA6C;AAE3E,oDAAoD;AACpD,qDAAmC;AAEnC,uBAAuB;AACvB,gDAA8B;AAC9B,gEAA8C;AAC9C,0DAAwC;AACxC,wEAAsD;AACtD,qCAAqC;AACxB,QAAA,eAAe,GAAG,mBAAQ,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;8EAO8E;;;;;;;;;;;;;;;;;AAE9E,4CAA2C;AAAlC,oGAAA,QAAQ,OAAA;AAEjB;;;;GAIG;AAEH,yDAAyD;AACzD,+CAA6B,CAAC,6CAA6C;AAE3E,oDAAoD;AACpD,qDAAmC;AAEnC,uBAAuB;AACvB,gDAA8B;AAC9B,gEAA8C;AAC9C,0DAAwC;AACxC,wEAAsD;AAEtD,sDAK8B;AAJ5B,yGAAA,QAAQ,OAAA;AACR,oHAAA,mBAAmB,OAAA;AACnB,oHAAA,mBAAmB,OAAA;AACnB,4GAAA,WAAW,OAAA"}