@systemix/password 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shahadathhs
+
+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,70 @@
+# @systemix/password
+
+`@systemix/password` is a customizable, lightweight, and cryptographically secure password generator for JavaScript and TypeScript. Built for maximum security, it relies entirely on Node.js built-in `crypto` modules, ensuring zero external dependencies and a low supply-chain risk profile.
+
+## Features
+
+- **Secure**: Uses `crypto.getRandomValues()` for cryptographically strong random data.
+- **Zero Dependencies**: Purely built with Node.js built-ins.
+- **TypeScript Ready**: Full type definitions included.
+- **Customizable**: Control length, character sets (numbers, symbols, uppercase, lowercase), and exclude similar characters.
+- **Validation**: Built-in strict validation for generation options.
+
+## Installation
+
+```bash
+pnpm add @systemix/password
+```
+
+or
+
+```bash
+npm install @systemix/password
+```
+
+## Usage
+
+### Simple Example
+
+```typescript
+import { generatePassword } from '@systemix/password';
+
+const password = generatePassword({
+  length: 16,
+  useNumbers: true,
+  useSymbols: true,
+  useUppercase: true,
+  useLowercase: true,
+});
+
+console.log(password); // Example: "Z#kM@4p*J!h2X&b7"
+```
+
+### Advanced Configuration
+
+```typescript
+const password = generatePassword({
+  length: 12,
+  useNumbers: true,
+  excludeSimilarCharacters: true, // Excludes: i, l, 1, L, o, 0, O
+  exclude: 'abc', // Manually exclude specific characters
+});
+```
+
+## API Reference
+
+### `generatePassword(props?: PasswordProps): string`
+
+| Property                   | Type      | Default | Description                          |
+| :------------------------- | :-------- | :------ | :----------------------------------- |
+| `length`                   | `number`  | `8`     | Password length (1 to 50).           |
+| `useNumbers`               | `boolean` | `true`  | Include 0-9.                         |
+| `useUppercase`             | `boolean` | `true`  | Include A-Z.                         |
+| `useLowercase`             | `boolean` | `true`  | Include a-z.                         |
+| `useSymbols`               | `boolean` | `false` | Include special characters.          |
+| `excludeSimilarCharacters` | `boolean` | `false` | Exclude visually similar characters. |
+| `exclude`                  | `string`  | `""`    | Specific characters to exclude.      |
+
+## License
+
+MIT © [shahadathhs](https://github.com/shahadathhs)

package/dist/index.cjs

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GeneratePasswordPropsEnum: () => GeneratePasswordPropsEnum,
+  allOptionsFalseError: () => allOptionsFalseError,
+  countError: () => countError,
+  excludeError: () => excludeError,
+  excludeSimilarCharactersError: () => excludeSimilarCharactersError,
+  generatePassword: () => generatePassword,
+  lengthError: () => lengthError,
+  unwantedPropsError: () => unwantedPropsError,
+  useLowercaseError: () => useLowercaseError,
+  useNumbersError: () => useNumbersError,
+  useSymbolsError: () => useSymbolsError,
+  useUppercaseError: () => useUppercaseError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/enum/props.enum.ts
+var GeneratePasswordPropsEnum = /* @__PURE__ */ ((GeneratePasswordPropsEnum2) => {
+  GeneratePasswordPropsEnum2["LENGTH"] = "length";
+  GeneratePasswordPropsEnum2["USE_NUMBERS"] = "useNumbers";
+  GeneratePasswordPropsEnum2["USE_UPPERCASE"] = "useUppercase";
+  GeneratePasswordPropsEnum2["USE_LOWERCASE"] = "useLowercase";
+  GeneratePasswordPropsEnum2["USE_SYMBOLS"] = "useSymbols";
+  GeneratePasswordPropsEnum2["EXCLUDE_SIMILAR_CHARACTERS"] = "excludeSimilarCharacters";
+  GeneratePasswordPropsEnum2["EXCLUDE"] = "exclude";
+  GeneratePasswordPropsEnum2["COUNT"] = "count";
+  return GeneratePasswordPropsEnum2;
+})(GeneratePasswordPropsEnum || {});
+
+// src/functions/generate.function.ts
+var import_node_crypto = require("crypto");
+
+// src/utils/error.message.ts
+var lengthError = {
+  invalidLength: "Invalid length. Length must be a positive number.",
+  lengthTooLarge: "Invalid length. Length must be less than or equal to 50."
+};
+var useNumbersError = "Invalid useNumbers. It must be a boolean value.";
+var useUppercaseError = "Invalid useUppercase. It must be a boolean value.";
+var useLowercaseError = "Invalid useLowercase. It must be a boolean value.";
+var useSymbolsError = "Invalid useSymbols. It must be a boolean value.";
+var excludeSimilarCharactersError = "Invalid excludeSimilarCharacters. It must be a boolean value.";
+var excludeError = "Invalid exclude. It must be a string.";
+var countError = {
+  invalidCount: "Invalid count. Count must be a positive number.",
+  countTooLarge: "Invalid count. Count must be less than or equal to 10."
+};
+var unwantedPropsError = (unwantedProps) => {
+  return `Invalid prop(s): ${unwantedProps.join(", ")}. Only the following options are allowed: length, useNumbers, useUppercase, useLowercase, useSymbols, excludeSimilarCharacters, exclude, count.`;
+};
+var allOptionsFalseError = "At least one of the options must be true.";
+
+// src/functions/validation.function.ts
+var allValidProps = Object.values(GeneratePasswordPropsEnum);
+function generatePasswordPropValidation(props) {
+  const propsValue = Object.keys(props);
+  const unwantedProps = propsValue.filter(
+    (prop) => !allValidProps.includes(prop)
+  );
+  if (unwantedProps.length > 0) {
+    throw new Error(unwantedPropsError(unwantedProps));
+  }
+  const {
+    length,
+    useNumbers,
+    useUppercase,
+    useLowercase,
+    useSymbols,
+    excludeSimilarCharacters,
+    exclude,
+    count
+  } = props;
+  if (typeof length !== "number" || length < 1) {
+    throw new Error(lengthError.invalidLength);
+  }
+  if (length > 50) {
+    throw new Error(lengthError.lengthTooLarge);
+  }
+  if (typeof useNumbers !== "boolean") {
+    throw new Error(useNumbersError);
+  }
+  if (typeof useUppercase !== "boolean") {
+    throw new Error(useUppercaseError);
+  }
+  if (typeof useLowercase !== "boolean") {
+    throw new Error(useLowercaseError);
+  }
+  if (typeof useSymbols !== "boolean") {
+    throw new Error(useSymbolsError);
+  }
+  if (typeof excludeSimilarCharacters !== "boolean") {
+    throw new Error(excludeSimilarCharactersError);
+  }
+  if (typeof exclude !== "string") {
+    throw new Error(excludeError);
+  }
+  if (typeof count !== "number" || count < 1) {
+    throw new Error(countError.invalidCount);
+  }
+  if (count > 10) {
+    throw new Error(countError.countTooLarge);
+  }
+  if (!useNumbers && !useUppercase && !useLowercase && !useSymbols) {
+    throw new Error(allOptionsFalseError);
+  }
+}
+
+// src/functions/generate.function.ts
+function generatePassword(props = {}) {
+  const {
+    length = 8,
+    useNumbers = true,
+    useUppercase = true,
+    useLowercase = true,
+    useSymbols = false,
+    excludeSimilarCharacters = false,
+    exclude = "",
+    count = 1,
+    ...extraProps
+  } = props;
+  const allProps = {
+    length,
+    useNumbers,
+    useUppercase,
+    useLowercase,
+    useSymbols,
+    excludeSimilarCharacters,
+    exclude,
+    count,
+    ...extraProps
+  };
+  generatePasswordPropValidation(allProps);
+  const lowercaseChars = "abcdefghijklmnopqrstuvwxyz";
+  const uppercaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const numberChars = "0123456789";
+  const symbolChars = "@#$%^&*()_+=<>?/|";
+  const similarChars = "il1Lo0O";
+  let charset = "";
+  const charsetOptions = [
+    { condition: useLowercase, value: lowercaseChars },
+    { condition: useUppercase, value: uppercaseChars },
+    { condition: useNumbers, value: numberChars },
+    { condition: useSymbols, value: symbolChars }
+  ];
+  charset = charsetOptions.reduce((acc, { condition, value }) => {
+    return condition ? acc + value : acc;
+  }, "");
+  if (excludeSimilarCharacters) {
+    charset = charset.split("").filter((char) => !similarChars.includes(char)).join("");
+  }
+  if (exclude) {
+    charset = charset.split("").filter((char) => !exclude.includes(char)).join("");
+  }
+  if (charset.length === 0) {
+    throw new Error("No valid characters to generate password.");
+  }
+  const generateSinglePassword = () => {
+    const randomIndices = new Uint32Array(length);
+    import_node_crypto.webcrypto.getRandomValues(randomIndices);
+    const password = Array.from(randomIndices).map((index) => charset[index % charset.length]).join("");
+    return password;
+  };
+  if (count === 1) return generateSinglePassword();
+  return Array.from({ length: count }, generateSinglePassword);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GeneratePasswordPropsEnum,
+  allOptionsFalseError,
+  countError,
+  excludeError,
+  excludeSimilarCharactersError,
+  generatePassword,
+  lengthError,
+  unwantedPropsError,
+  useLowercaseError,
+  useNumbersError,
+  useSymbolsError,
+  useUppercaseError
+});

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+declare enum GeneratePasswordPropsEnum {
+    LENGTH = "length",
+    USE_NUMBERS = "useNumbers",
+    USE_UPPERCASE = "useUppercase",
+    USE_LOWERCASE = "useLowercase",
+    USE_SYMBOLS = "useSymbols",
+    EXCLUDE_SIMILAR_CHARACTERS = "excludeSimilarCharacters",
+    EXCLUDE = "exclude",
+    COUNT = "count"
+}
+
+type GeneratePasswordFunctionProps = {
+    [key in GeneratePasswordPropsEnum]?: key extends GeneratePasswordPropsEnum.LENGTH | GeneratePasswordPropsEnum.COUNT ? number : key extends GeneratePasswordPropsEnum.EXCLUDE ? string : key extends GeneratePasswordPropsEnum.USE_NUMBERS | GeneratePasswordPropsEnum.USE_UPPERCASE | GeneratePasswordPropsEnum.USE_LOWERCASE | GeneratePasswordPropsEnum.USE_SYMBOLS | GeneratePasswordPropsEnum.EXCLUDE_SIMILAR_CHARACTERS ? boolean : never;
+};
+
+declare function generatePassword(props?: GeneratePasswordFunctionProps): string | string[];
+
+declare const lengthError: {
+    invalidLength: string;
+    lengthTooLarge: string;
+};
+declare const useNumbersError = "Invalid useNumbers. It must be a boolean value.";
+declare const useUppercaseError = "Invalid useUppercase. It must be a boolean value.";
+declare const useLowercaseError = "Invalid useLowercase. It must be a boolean value.";
+declare const useSymbolsError = "Invalid useSymbols. It must be a boolean value.";
+declare const excludeSimilarCharactersError = "Invalid excludeSimilarCharacters. It must be a boolean value.";
+declare const excludeError = "Invalid exclude. It must be a string.";
+declare const countError: {
+    invalidCount: string;
+    countTooLarge: string;
+};
+declare const unwantedPropsError: (unwantedProps: string[]) => string;
+declare const allOptionsFalseError = "At least one of the options must be true.";
+
+export { type GeneratePasswordFunctionProps, GeneratePasswordPropsEnum, allOptionsFalseError, countError, excludeError, excludeSimilarCharactersError, generatePassword, lengthError, unwantedPropsError, useLowercaseError, useNumbersError, useSymbolsError, useUppercaseError };

package/dist/index.d.mts

@@ -0,0 +1,35 @@
+declare enum GeneratePasswordPropsEnum {
+    LENGTH = "length",
+    USE_NUMBERS = "useNumbers",
+    USE_UPPERCASE = "useUppercase",
+    USE_LOWERCASE = "useLowercase",
+    USE_SYMBOLS = "useSymbols",
+    EXCLUDE_SIMILAR_CHARACTERS = "excludeSimilarCharacters",
+    EXCLUDE = "exclude",
+    COUNT = "count"
+}
+
+type GeneratePasswordFunctionProps = {
+    [key in GeneratePasswordPropsEnum]?: key extends GeneratePasswordPropsEnum.LENGTH | GeneratePasswordPropsEnum.COUNT ? number : key extends GeneratePasswordPropsEnum.EXCLUDE ? string : key extends GeneratePasswordPropsEnum.USE_NUMBERS | GeneratePasswordPropsEnum.USE_UPPERCASE | GeneratePasswordPropsEnum.USE_LOWERCASE | GeneratePasswordPropsEnum.USE_SYMBOLS | GeneratePasswordPropsEnum.EXCLUDE_SIMILAR_CHARACTERS ? boolean : never;
+};
+
+declare function generatePassword(props?: GeneratePasswordFunctionProps): string | string[];
+
+declare const lengthError: {
+    invalidLength: string;
+    lengthTooLarge: string;
+};
+declare const useNumbersError = "Invalid useNumbers. It must be a boolean value.";
+declare const useUppercaseError = "Invalid useUppercase. It must be a boolean value.";
+declare const useLowercaseError = "Invalid useLowercase. It must be a boolean value.";
+declare const useSymbolsError = "Invalid useSymbols. It must be a boolean value.";
+declare const excludeSimilarCharactersError = "Invalid excludeSimilarCharacters. It must be a boolean value.";
+declare const excludeError = "Invalid exclude. It must be a string.";
+declare const countError: {
+    invalidCount: string;
+    countTooLarge: string;
+};
+declare const unwantedPropsError: (unwantedProps: string[]) => string;
+declare const allOptionsFalseError = "At least one of the options must be true.";
+
+export { type GeneratePasswordFunctionProps, GeneratePasswordPropsEnum, allOptionsFalseError, countError, excludeError, excludeSimilarCharactersError, generatePassword, lengthError, unwantedPropsError, useLowercaseError, useNumbersError, useSymbolsError, useUppercaseError };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+declare enum GeneratePasswordPropsEnum {
+    LENGTH = "length",
+    USE_NUMBERS = "useNumbers",
+    USE_UPPERCASE = "useUppercase",
+    USE_LOWERCASE = "useLowercase",
+    USE_SYMBOLS = "useSymbols",
+    EXCLUDE_SIMILAR_CHARACTERS = "excludeSimilarCharacters",
+    EXCLUDE = "exclude",
+    COUNT = "count"
+}
+
+type GeneratePasswordFunctionProps = {
+    [key in GeneratePasswordPropsEnum]?: key extends GeneratePasswordPropsEnum.LENGTH | GeneratePasswordPropsEnum.COUNT ? number : key extends GeneratePasswordPropsEnum.EXCLUDE ? string : key extends GeneratePasswordPropsEnum.USE_NUMBERS | GeneratePasswordPropsEnum.USE_UPPERCASE | GeneratePasswordPropsEnum.USE_LOWERCASE | GeneratePasswordPropsEnum.USE_SYMBOLS | GeneratePasswordPropsEnum.EXCLUDE_SIMILAR_CHARACTERS ? boolean : never;
+};
+
+declare function generatePassword(props?: GeneratePasswordFunctionProps): string | string[];
+
+declare const lengthError: {
+    invalidLength: string;
+    lengthTooLarge: string;
+};
+declare const useNumbersError = "Invalid useNumbers. It must be a boolean value.";
+declare const useUppercaseError = "Invalid useUppercase. It must be a boolean value.";
+declare const useLowercaseError = "Invalid useLowercase. It must be a boolean value.";
+declare const useSymbolsError = "Invalid useSymbols. It must be a boolean value.";
+declare const excludeSimilarCharactersError = "Invalid excludeSimilarCharacters. It must be a boolean value.";
+declare const excludeError = "Invalid exclude. It must be a string.";
+declare const countError: {
+    invalidCount: string;
+    countTooLarge: string;
+};
+declare const unwantedPropsError: (unwantedProps: string[]) => string;
+declare const allOptionsFalseError = "At least one of the options must be true.";
+
+export { type GeneratePasswordFunctionProps, GeneratePasswordPropsEnum, allOptionsFalseError, countError, excludeError, excludeSimilarCharactersError, generatePassword, lengthError, unwantedPropsError, useLowercaseError, useNumbersError, useSymbolsError, useUppercaseError };

package/dist/index.js

@@ -0,0 +1,163 @@
+// src/enum/props.enum.ts
+var GeneratePasswordPropsEnum = /* @__PURE__ */ ((GeneratePasswordPropsEnum2) => {
+  GeneratePasswordPropsEnum2["LENGTH"] = "length";
+  GeneratePasswordPropsEnum2["USE_NUMBERS"] = "useNumbers";
+  GeneratePasswordPropsEnum2["USE_UPPERCASE"] = "useUppercase";
+  GeneratePasswordPropsEnum2["USE_LOWERCASE"] = "useLowercase";
+  GeneratePasswordPropsEnum2["USE_SYMBOLS"] = "useSymbols";
+  GeneratePasswordPropsEnum2["EXCLUDE_SIMILAR_CHARACTERS"] = "excludeSimilarCharacters";
+  GeneratePasswordPropsEnum2["EXCLUDE"] = "exclude";
+  GeneratePasswordPropsEnum2["COUNT"] = "count";
+  return GeneratePasswordPropsEnum2;
+})(GeneratePasswordPropsEnum || {});
+
+// src/functions/generate.function.ts
+import { webcrypto as crypto } from "crypto";
+
+// src/utils/error.message.ts
+var lengthError = {
+  invalidLength: "Invalid length. Length must be a positive number.",
+  lengthTooLarge: "Invalid length. Length must be less than or equal to 50."
+};
+var useNumbersError = "Invalid useNumbers. It must be a boolean value.";
+var useUppercaseError = "Invalid useUppercase. It must be a boolean value.";
+var useLowercaseError = "Invalid useLowercase. It must be a boolean value.";
+var useSymbolsError = "Invalid useSymbols. It must be a boolean value.";
+var excludeSimilarCharactersError = "Invalid excludeSimilarCharacters. It must be a boolean value.";
+var excludeError = "Invalid exclude. It must be a string.";
+var countError = {
+  invalidCount: "Invalid count. Count must be a positive number.",
+  countTooLarge: "Invalid count. Count must be less than or equal to 10."
+};
+var unwantedPropsError = (unwantedProps) => {
+  return `Invalid prop(s): ${unwantedProps.join(", ")}. Only the following options are allowed: length, useNumbers, useUppercase, useLowercase, useSymbols, excludeSimilarCharacters, exclude, count.`;
+};
+var allOptionsFalseError = "At least one of the options must be true.";
+
+// src/functions/validation.function.ts
+var allValidProps = Object.values(GeneratePasswordPropsEnum);
+function generatePasswordPropValidation(props) {
+  const propsValue = Object.keys(props);
+  const unwantedProps = propsValue.filter(
+    (prop) => !allValidProps.includes(prop)
+  );
+  if (unwantedProps.length > 0) {
+    throw new Error(unwantedPropsError(unwantedProps));
+  }
+  const {
+    length,
+    useNumbers,
+    useUppercase,
+    useLowercase,
+    useSymbols,
+    excludeSimilarCharacters,
+    exclude,
+    count
+  } = props;
+  if (typeof length !== "number" || length < 1) {
+    throw new Error(lengthError.invalidLength);
+  }
+  if (length > 50) {
+    throw new Error(lengthError.lengthTooLarge);
+  }
+  if (typeof useNumbers !== "boolean") {
+    throw new Error(useNumbersError);
+  }
+  if (typeof useUppercase !== "boolean") {
+    throw new Error(useUppercaseError);
+  }
+  if (typeof useLowercase !== "boolean") {
+    throw new Error(useLowercaseError);
+  }
+  if (typeof useSymbols !== "boolean") {
+    throw new Error(useSymbolsError);
+  }
+  if (typeof excludeSimilarCharacters !== "boolean") {
+    throw new Error(excludeSimilarCharactersError);
+  }
+  if (typeof exclude !== "string") {
+    throw new Error(excludeError);
+  }
+  if (typeof count !== "number" || count < 1) {
+    throw new Error(countError.invalidCount);
+  }
+  if (count > 10) {
+    throw new Error(countError.countTooLarge);
+  }
+  if (!useNumbers && !useUppercase && !useLowercase && !useSymbols) {
+    throw new Error(allOptionsFalseError);
+  }
+}
+
+// src/functions/generate.function.ts
+function generatePassword(props = {}) {
+  const {
+    length = 8,
+    useNumbers = true,
+    useUppercase = true,
+    useLowercase = true,
+    useSymbols = false,
+    excludeSimilarCharacters = false,
+    exclude = "",
+    count = 1,
+    ...extraProps
+  } = props;
+  const allProps = {
+    length,
+    useNumbers,
+    useUppercase,
+    useLowercase,
+    useSymbols,
+    excludeSimilarCharacters,
+    exclude,
+    count,
+    ...extraProps
+  };
+  generatePasswordPropValidation(allProps);
+  const lowercaseChars = "abcdefghijklmnopqrstuvwxyz";
+  const uppercaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const numberChars = "0123456789";
+  const symbolChars = "@#$%^&*()_+=<>?/|";
+  const similarChars = "il1Lo0O";
+  let charset = "";
+  const charsetOptions = [
+    { condition: useLowercase, value: lowercaseChars },
+    { condition: useUppercase, value: uppercaseChars },
+    { condition: useNumbers, value: numberChars },
+    { condition: useSymbols, value: symbolChars }
+  ];
+  charset = charsetOptions.reduce((acc, { condition, value }) => {
+    return condition ? acc + value : acc;
+  }, "");
+  if (excludeSimilarCharacters) {
+    charset = charset.split("").filter((char) => !similarChars.includes(char)).join("");
+  }
+  if (exclude) {
+    charset = charset.split("").filter((char) => !exclude.includes(char)).join("");
+  }
+  if (charset.length === 0) {
+    throw new Error("No valid characters to generate password.");
+  }
+  const generateSinglePassword = () => {
+    const randomIndices = new Uint32Array(length);
+    crypto.getRandomValues(randomIndices);
+    const password = Array.from(randomIndices).map((index) => charset[index % charset.length]).join("");
+    return password;
+  };
+  if (count === 1) return generateSinglePassword();
+  return Array.from({ length: count }, generateSinglePassword);
+}
+export {
+  GeneratePasswordPropsEnum,
+  allOptionsFalseError,
+  countError,
+  excludeError,
+  excludeSimilarCharactersError,
+  generatePassword,
+  lengthError,
+  unwantedPropsError,
+  useLowercaseError,
+  useNumbersError,
+  useSymbolsError,
+  useUppercaseError
+};

package/dist/index.mjs

@@ -0,0 +1,158 @@
+// src/enum/props.enum.ts
+var GeneratePasswordPropsEnum = /* @__PURE__ */ ((GeneratePasswordPropsEnum2) => {
+  GeneratePasswordPropsEnum2["LENGTH"] = "length";
+  GeneratePasswordPropsEnum2["USE_NUMBERS"] = "useNumbers";
+  GeneratePasswordPropsEnum2["USE_UPPERCASE"] = "useUppercase";
+  GeneratePasswordPropsEnum2["USE_LOWERCASE"] = "useLowercase";
+  GeneratePasswordPropsEnum2["USE_SYMBOLS"] = "useSymbols";
+  GeneratePasswordPropsEnum2["EXCLUDE_SIMILAR_CHARACTERS"] = "excludeSimilarCharacters";
+  GeneratePasswordPropsEnum2["EXCLUDE"] = "exclude";
+  GeneratePasswordPropsEnum2["COUNT"] = "count";
+  return GeneratePasswordPropsEnum2;
+})(GeneratePasswordPropsEnum || {});
+
+// src/utils/error.message.ts
+var lengthError = {
+  invalidLength: "Invalid length. Length must be a positive number.",
+  lengthTooLarge: "Invalid length. Length must be less than or equal to 50."
+};
+var useNumbersError = "Invalid useNumbers. It must be a boolean value.";
+var useUppercaseError = "Invalid useUppercase. It must be a boolean value.";
+var useLowercaseError = "Invalid useLowercase. It must be a boolean value.";
+var useSymbolsError = "Invalid useSymbols. It must be a boolean value.";
+var excludeSimilarCharactersError = "Invalid excludeSimilarCharacters. It must be a boolean value.";
+var excludeError = "Invalid exclude. It must be a string.";
+var countError = {
+  invalidCount: "Invalid count. Count must be a positive number.",
+  countTooLarge: "Invalid count. Count must be less than or equal to 10."
+};
+var unwantedPropsError = (unwantedProps) => {
+  return `Invalid prop(s): ${unwantedProps.join(", ")}. Only the following options are allowed: length, useNumbers, useUppercase, useLowercase, useSymbols, excludeSimilarCharacters, exclude, count.`;
+};
+var allOptionsFalseError = "At least one of the options must be true.";
+
+// src/functions/validation.function.ts
+var allValidProps = Object.values(GeneratePasswordPropsEnum);
+function generatePasswordPropValidation(props) {
+  const propsValue = Object.keys(props);
+  const unwantedProps = propsValue.filter((prop) => !allValidProps.includes(prop));
+  if (unwantedProps.length > 0) {
+    throw new Error(unwantedPropsError(unwantedProps));
+  }
+  const {
+    length,
+    useNumbers,
+    useUppercase,
+    useLowercase,
+    useSymbols,
+    excludeSimilarCharacters,
+    exclude,
+    count
+  } = props;
+  if (typeof length !== "number" || length < 1) {
+    throw new Error(lengthError.invalidLength);
+  }
+  if (length > 50) {
+    throw new Error(lengthError.lengthTooLarge);
+  }
+  if (typeof useNumbers !== "boolean") {
+    throw new Error(useNumbersError);
+  }
+  if (typeof useUppercase !== "boolean") {
+    throw new Error(useUppercaseError);
+  }
+  if (typeof useLowercase !== "boolean") {
+    throw new Error(useLowercaseError);
+  }
+  if (typeof useSymbols !== "boolean") {
+    throw new Error(useSymbolsError);
+  }
+  if (typeof excludeSimilarCharacters !== "boolean") {
+    throw new Error(excludeSimilarCharactersError);
+  }
+  if (typeof exclude !== "string") {
+    throw new Error(excludeError);
+  }
+  if (typeof count !== "number" || count < 1) {
+    throw new Error(countError.invalidCount);
+  }
+  if (count > 10) {
+    throw new Error(countError.countTooLarge);
+  }
+  if (!useNumbers && !useUppercase && !useLowercase && !useSymbols) {
+    throw new Error(allOptionsFalseError);
+  }
+}
+
+// src/functions/generate.function.ts
+function generatePassword(props = {}) {
+  const {
+    length = 8,
+    useNumbers = true,
+    useUppercase = true,
+    useLowercase = true,
+    useSymbols = false,
+    excludeSimilarCharacters = false,
+    exclude = "",
+    count = 1,
+    ...extraProps
+  } = props;
+  const allProps = {
+    length,
+    useNumbers,
+    useUppercase,
+    useLowercase,
+    useSymbols,
+    excludeSimilarCharacters,
+    exclude,
+    count,
+    ...extraProps
+  };
+  generatePasswordPropValidation(allProps);
+  const lowercaseChars = "abcdefghijklmnopqrstuvwxyz";
+  const uppercaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const numberChars = "0123456789";
+  const symbolChars = "@#$%^&*()_+=<>?/|";
+  const similarChars = "il1Lo0O";
+  let charset = "";
+  const charsetOptions = [
+    { condition: useLowercase, value: lowercaseChars },
+    { condition: useUppercase, value: uppercaseChars },
+    { condition: useNumbers, value: numberChars },
+    { condition: useSymbols, value: symbolChars }
+  ];
+  charset = charsetOptions.reduce((acc, { condition, value }) => {
+    return condition ? acc + value : acc;
+  }, "");
+  if (excludeSimilarCharacters) {
+    charset = charset.split("").filter((char) => !similarChars.includes(char)).join("");
+  }
+  if (exclude) {
+    charset = charset.split("").filter((char) => !exclude.includes(char)).join("");
+  }
+  if (charset.length === 0) {
+    throw new Error("No valid characters to generate password.");
+  }
+  const generateSinglePassword = () => {
+    const randomIndices = new Uint32Array(length);
+    crypto.getRandomValues(randomIndices);
+    const password = Array.from(randomIndices).map((index) => charset[index % charset.length]).join("");
+    return password;
+  };
+  if (count === 1) return generateSinglePassword();
+  return Array.from({ length: count }, generateSinglePassword);
+}
+export {
+  GeneratePasswordPropsEnum,
+  allOptionsFalseError,
+  countError,
+  excludeError,
+  excludeSimilarCharactersError,
+  generatePassword,
+  lengthError,
+  unwantedPropsError,
+  useLowercaseError,
+  useNumbersError,
+  useSymbolsError,
+  useUppercaseError
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@systemix/password",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shahadathhs/systemix.git",
+    "directory": "packages/password"
+  },
+  "homepage": "https://github.com/shahadathhs/systemix/tree/main/packages/password#readme",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --check . --ignore-path .prettierignore",
+    "format:fix": "prettier --write . --ignore-path .prettierignore",
+    "clean": "rimraf dist node_modules",
+    "clean:turbo": "rimraf .turbo dist node_modules",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "systemix",
+    "password",
+    "generator",
+    "password-generator",
+    "secure-password",
+    "strong-passwords",
+    "crypto",
+    "typescript",
+    "node",
+    "utility"
+  ],
+  "author": "Shahadath Hossain <shahadath.dev@gmail.com> (https://github.com/shahadathhs)",
+  "license": "MIT",
+  "description": "A cryptographically secure password generator with customizable complexity. Part of the Systemix toolkit.",
+  "devDependencies": {
+    "@systemix/eslint": "workspace:*",
+    "@systemix/typescript": "workspace:*",
+    "@types/node": "^25.2.3",
+    "eslint": "^10.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "directories": {
+    "test": "tests"
+  },
+  "sideEffects": [
+    "*.css",
+    "*.scss"
+  ],
+  "bugs": {
+    "url": "https://github.com/shahadathhs/systemix/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ]
+}