@salespark/toolkit 2.1.19 → 2.1.21

package/dist/index.d.cts

@@ -1027,8 +1027,83 @@ declare const decodeBase36Code: (code: string, config: EncodeDecodeConfig) => Sa
     identifier: string;
 }>;
 
+/******************************************************
+ * ##: Password Generator (sync + async modes)
+ * Generates random passwords with optional memorable and pattern-based modes.
+ * Supports deterministic entropy and passphrase words in async mode.
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+type GenerateOptions = {
+    length?: number;
+    memorable?: boolean;
+    pattern?: RegExp;
+    prefix?: string;
+    ignoreSecurityRecommendations?: boolean;
+    entropy?: Uint8Array | string;
+    words?: number;
+};
+/******************************************************
+ * ##: Generate Password
+ * Default sync implementation; returns a Promise when async options are used.
+ * @param {Number} length - Password length
+ * @param {Boolean} memorable - Alternates consonants and vowels
+ * @param {RegExp} pattern - Pattern applied to each character
+ * @param {String} prefix - Prefix appended to the password
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+declare function generatePassword(length?: number, memorable?: boolean, pattern?: RegExp, prefix?: string): string;
+declare function generatePassword(options?: GenerateOptions): string | Promise<string>;
+/******************************************************
+ * ##: Generate Password (options wrapper)
+ * Full options support including async features (words, entropy).
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+declare const generatePasswordWithOptions: (options?: GenerateOptions) => string | Promise<string>;
+
+/******************************************************
+ * ##: SMS Length Calculator
+ * Calculates SMS length, segmentation, and encoding based on GSM rules.
+ * Reference: 3GPP TS 23.038 (GSM 03.38)
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+type SmsEncoding = "GSM_7BIT" | "GSM_7BIT_EXT" | "UTF16";
+declare const GSM_7BIT_REGEXP: RegExp;
+declare const GSM_7BIT_EXT_REGEXP: RegExp;
+/******************************************************
+ * Extended GSM characters that consume 2 septets each.
+ * Per 3GPP TS 23.038 Table 3 (Basic Character Set Extension):
+ * ^ { } \ [ ] ~ | €
+ ****************************************************/
+declare const GSM_7BIT_EXT_CHAR_REGEXP: RegExp;
+type SmsLengthResult = {
+    encoding: SmsEncoding;
+    length: number;
+    characterPerMessage: number;
+    inCurrentMessage: number;
+    remaining: number;
+    messages: number;
+};
+/******************************************************
+ * ##: SMS Length
+ * Calculates encoding, length, and segmentation for an SMS message.
+ * Extended GSM characters (^{}\\[]~|€) each count as 2 septets.
+ * Supports optional per-encoding length overrides for carrier-specific limits.
+ * @param {string} text - SMS message text
+ * @param {Partial<Record<SmsEncoding, number>>} [singleOverrides] - Override
+ *   single-segment lengths per encoding
+ * @param {Partial<Record<SmsEncoding, number>>} [multiOverrides] - Override
+ *   multi-segment lengths per encoding
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+declare const smsLength: (text: string, singleOverrides?: Partial<Record<SmsEncoding, number>>, multiOverrides?: Partial<Record<SmsEncoding, number>>) => SmsLengthResult;
+
 /** Environment helpers (runtime-agnostic checks) */
 declare const isBrowser: boolean;
 declare const isNode: boolean;
 
-export { type CapitalizeFirstOptions, type CapitalizeWordsOptions, type DeferFn, type EncodeDecodeConfig, type FormatCurrencyProOptions, type HttpResponseLike, type SecurityCheckResult, type SecurityRisk, type SentenceCaseOptions, addSpaceBetweenNumbers, addThousandsSpace, areArraysDeepEqualUnordered, areArraysEqual, assessSecurityRisks, basicSanitize, capitalizeFirst, capitalizeWords, checkMarkdownSecurity, chunk, clamp, cleanObject, compact, currencyToSymbol, debounce, deburr, decodeBase36Code, decodeObject, decodeString, deferAfterResponse, deferAfterResponseNonCritical, deferNonCritical, deferPostReturn, delay, difference, encodeBase36Code, encodeObject, encodeString, fill, flatten, flattenDepth, flattenDepthBase, flattenOnce, formatBytes, formatCurrency, formatCurrencyPro, formatDecimalNumber, getStringSimilarity, groupBy, hasNilOrEmpty, humanFileSize, intersection, isBrowser, isFlattenable, isNil, isNilEmptyOrEmptyObject, isNilEmptyOrZeroLen, isNilEmptyOrZeroLength, isNilOrEmpty, isNilOrNaN, isNilOrZeroLen, isNilOrZeroLength, isNilText, isNilTextOrEmpty, isNode, isNullOrUndefined, isNullOrUndefinedEmptyOrZero, isNullOrUndefinedInArray, isNullOrUndefinedOrNaN, isNullOrUndefinedTextInc, isNullUndefinedOrEmpty, isNullUndefinedOrEmptyEnforced, isNullUndefinedOrZero, isPTTaxId, isValidIBAN, isValidPTTaxId, numbersEqual, objectToString, omit, otp, parseName, parseToBool, parseToNumber, pick, pluck, pushAll, randomDigits, removeDiacritics, round, safeAdd, safeDivide, safeJSONParse, safeMultiply, safeParseFloat, safeParseInt, safeSubtract, sanitize, sanitizeMarkdown, sentenceCase, shuffle, slugify, sortBy, stringSimilarity, symbolToCurrency, throttle, toBool, toInteger, toNumber, uniq, uniqBy };
+export { type CapitalizeFirstOptions, type CapitalizeWordsOptions, type DeferFn, type EncodeDecodeConfig, type FormatCurrencyProOptions, GSM_7BIT_EXT_CHAR_REGEXP, GSM_7BIT_EXT_REGEXP, GSM_7BIT_REGEXP, type GenerateOptions, type HttpResponseLike, type SecurityCheckResult, type SecurityRisk, type SentenceCaseOptions, type SmsEncoding, type SmsLengthResult, addSpaceBetweenNumbers, addThousandsSpace, areArraysDeepEqualUnordered, areArraysEqual, assessSecurityRisks, basicSanitize, capitalizeFirst, capitalizeWords, checkMarkdownSecurity, chunk, clamp, cleanObject, compact, currencyToSymbol, debounce, deburr, decodeBase36Code, decodeObject, decodeString, deferAfterResponse, deferAfterResponseNonCritical, deferNonCritical, deferPostReturn, delay, difference, encodeBase36Code, encodeObject, encodeString, fill, flatten, flattenDepth, flattenDepthBase, flattenOnce, formatBytes, formatCurrency, formatCurrencyPro, formatDecimalNumber, generatePassword, generatePasswordWithOptions, getStringSimilarity, groupBy, hasNilOrEmpty, humanFileSize, intersection, isBrowser, isFlattenable, isNil, isNilEmptyOrEmptyObject, isNilEmptyOrZeroLen, isNilEmptyOrZeroLength, isNilOrEmpty, isNilOrNaN, isNilOrZeroLen, isNilOrZeroLength, isNilText, isNilTextOrEmpty, isNode, isNullOrUndefined, isNullOrUndefinedEmptyOrZero, isNullOrUndefinedInArray, isNullOrUndefinedOrNaN, isNullOrUndefinedTextInc, isNullUndefinedOrEmpty, isNullUndefinedOrEmptyEnforced, isNullUndefinedOrZero, isPTTaxId, isValidIBAN, isValidPTTaxId, numbersEqual, objectToString, omit, otp, parseName, parseToBool, parseToNumber, pick, pluck, pushAll, randomDigits, removeDiacritics, round, safeAdd, safeDivide, safeJSONParse, safeMultiply, safeParseFloat, safeParseInt, safeSubtract, sanitize, sanitizeMarkdown, sentenceCase, shuffle, slugify, smsLength, sortBy, stringSimilarity, symbolToCurrency, throttle, toBool, toInteger, toNumber, uniq, uniqBy };

package/dist/index.d.ts

@@ -1027,8 +1027,83 @@ declare const decodeBase36Code: (code: string, config: EncodeDecodeConfig) => Sa
     identifier: string;
 }>;
 
+/******************************************************
+ * ##: Password Generator (sync + async modes)
+ * Generates random passwords with optional memorable and pattern-based modes.
+ * Supports deterministic entropy and passphrase words in async mode.
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+type GenerateOptions = {
+    length?: number;
+    memorable?: boolean;
+    pattern?: RegExp;
+    prefix?: string;
+    ignoreSecurityRecommendations?: boolean;
+    entropy?: Uint8Array | string;
+    words?: number;
+};
+/******************************************************
+ * ##: Generate Password
+ * Default sync implementation; returns a Promise when async options are used.
+ * @param {Number} length - Password length
+ * @param {Boolean} memorable - Alternates consonants and vowels
+ * @param {RegExp} pattern - Pattern applied to each character
+ * @param {String} prefix - Prefix appended to the password
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+declare function generatePassword(length?: number, memorable?: boolean, pattern?: RegExp, prefix?: string): string;
+declare function generatePassword(options?: GenerateOptions): string | Promise<string>;
+/******************************************************
+ * ##: Generate Password (options wrapper)
+ * Full options support including async features (words, entropy).
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+declare const generatePasswordWithOptions: (options?: GenerateOptions) => string | Promise<string>;
+
+/******************************************************
+ * ##: SMS Length Calculator
+ * Calculates SMS length, segmentation, and encoding based on GSM rules.
+ * Reference: 3GPP TS 23.038 (GSM 03.38)
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+type SmsEncoding = "GSM_7BIT" | "GSM_7BIT_EXT" | "UTF16";
+declare const GSM_7BIT_REGEXP: RegExp;
+declare const GSM_7BIT_EXT_REGEXP: RegExp;
+/******************************************************
+ * Extended GSM characters that consume 2 septets each.
+ * Per 3GPP TS 23.038 Table 3 (Basic Character Set Extension):
+ * ^ { } \ [ ] ~ | €
+ ****************************************************/
+declare const GSM_7BIT_EXT_CHAR_REGEXP: RegExp;
+type SmsLengthResult = {
+    encoding: SmsEncoding;
+    length: number;
+    characterPerMessage: number;
+    inCurrentMessage: number;
+    remaining: number;
+    messages: number;
+};
+/******************************************************
+ * ##: SMS Length
+ * Calculates encoding, length, and segmentation for an SMS message.
+ * Extended GSM characters (^{}\\[]~|€) each count as 2 septets.
+ * Supports optional per-encoding length overrides for carrier-specific limits.
+ * @param {string} text - SMS message text
+ * @param {Partial<Record<SmsEncoding, number>>} [singleOverrides] - Override
+ *   single-segment lengths per encoding
+ * @param {Partial<Record<SmsEncoding, number>>} [multiOverrides] - Override
+ *   multi-segment lengths per encoding
+ * History:
+ * 14-03-2026: Created
+ ****************************************************/
+declare const smsLength: (text: string, singleOverrides?: Partial<Record<SmsEncoding, number>>, multiOverrides?: Partial<Record<SmsEncoding, number>>) => SmsLengthResult;
+
 /** Environment helpers (runtime-agnostic checks) */
 declare const isBrowser: boolean;
 declare const isNode: boolean;
 
-export { type CapitalizeFirstOptions, type CapitalizeWordsOptions, type DeferFn, type EncodeDecodeConfig, type FormatCurrencyProOptions, type HttpResponseLike, type SecurityCheckResult, type SecurityRisk, type SentenceCaseOptions, addSpaceBetweenNumbers, addThousandsSpace, areArraysDeepEqualUnordered, areArraysEqual, assessSecurityRisks, basicSanitize, capitalizeFirst, capitalizeWords, checkMarkdownSecurity, chunk, clamp, cleanObject, compact, currencyToSymbol, debounce, deburr, decodeBase36Code, decodeObject, decodeString, deferAfterResponse, deferAfterResponseNonCritical, deferNonCritical, deferPostReturn, delay, difference, encodeBase36Code, encodeObject, encodeString, fill, flatten, flattenDepth, flattenDepthBase, flattenOnce, formatBytes, formatCurrency, formatCurrencyPro, formatDecimalNumber, getStringSimilarity, groupBy, hasNilOrEmpty, humanFileSize, intersection, isBrowser, isFlattenable, isNil, isNilEmptyOrEmptyObject, isNilEmptyOrZeroLen, isNilEmptyOrZeroLength, isNilOrEmpty, isNilOrNaN, isNilOrZeroLen, isNilOrZeroLength, isNilText, isNilTextOrEmpty, isNode, isNullOrUndefined, isNullOrUndefinedEmptyOrZero, isNullOrUndefinedInArray, isNullOrUndefinedOrNaN, isNullOrUndefinedTextInc, isNullUndefinedOrEmpty, isNullUndefinedOrEmptyEnforced, isNullUndefinedOrZero, isPTTaxId, isValidIBAN, isValidPTTaxId, numbersEqual, objectToString, omit, otp, parseName, parseToBool, parseToNumber, pick, pluck, pushAll, randomDigits, removeDiacritics, round, safeAdd, safeDivide, safeJSONParse, safeMultiply, safeParseFloat, safeParseInt, safeSubtract, sanitize, sanitizeMarkdown, sentenceCase, shuffle, slugify, sortBy, stringSimilarity, symbolToCurrency, throttle, toBool, toInteger, toNumber, uniq, uniqBy };
+export { type CapitalizeFirstOptions, type CapitalizeWordsOptions, type DeferFn, type EncodeDecodeConfig, type FormatCurrencyProOptions, GSM_7BIT_EXT_CHAR_REGEXP, GSM_7BIT_EXT_REGEXP, GSM_7BIT_REGEXP, type GenerateOptions, type HttpResponseLike, type SecurityCheckResult, type SecurityRisk, type SentenceCaseOptions, type SmsEncoding, type SmsLengthResult, addSpaceBetweenNumbers, addThousandsSpace, areArraysDeepEqualUnordered, areArraysEqual, assessSecurityRisks, basicSanitize, capitalizeFirst, capitalizeWords, checkMarkdownSecurity, chunk, clamp, cleanObject, compact, currencyToSymbol, debounce, deburr, decodeBase36Code, decodeObject, decodeString, deferAfterResponse, deferAfterResponseNonCritical, deferNonCritical, deferPostReturn, delay, difference, encodeBase36Code, encodeObject, encodeString, fill, flatten, flattenDepth, flattenDepthBase, flattenOnce, formatBytes, formatCurrency, formatCurrencyPro, formatDecimalNumber, generatePassword, generatePasswordWithOptions, getStringSimilarity, groupBy, hasNilOrEmpty, humanFileSize, intersection, isBrowser, isFlattenable, isNil, isNilEmptyOrEmptyObject, isNilEmptyOrZeroLen, isNilEmptyOrZeroLength, isNilOrEmpty, isNilOrNaN, isNilOrZeroLen, isNilOrZeroLength, isNilText, isNilTextOrEmpty, isNode, isNullOrUndefined, isNullOrUndefinedEmptyOrZero, isNullOrUndefinedInArray, isNullOrUndefinedOrNaN, isNullOrUndefinedTextInc, isNullUndefinedOrEmpty, isNullUndefinedOrEmptyEnforced, isNullUndefinedOrZero, isPTTaxId, isValidIBAN, isValidPTTaxId, numbersEqual, objectToString, omit, otp, parseName, parseToBool, parseToNumber, pick, pluck, pushAll, randomDigits, removeDiacritics, round, safeAdd, safeDivide, safeJSONParse, safeMultiply, safeParseFloat, safeParseInt, safeSubtract, sanitize, sanitizeMarkdown, sentenceCase, shuffle, slugify, smsLength, sortBy, stringSimilarity, symbolToCurrency, throttle, toBool, toInteger, toNumber, uniq, uniqBy };

package/dist/index.js

@@ -2220,10 +2220,464 @@ var decodeBase36Code = (code, config) => {
   }
 };
 
+// src/utils/password.ts
+var hasCrypto = typeof globalThis !== "undefined" && typeof globalThis.crypto !== "undefined";
+var cryptoSource = hasCrypto ? globalThis.crypto : void 0;
+var textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+var MAX_RANDOM_BYTES = 65536;
+var VOWELS = "aeiou";
+var CONSONANTS = "bcdfghjklmnpqrstvwxyz";
+var CONSONANT = new RegExp(`[${CONSONANTS}]$`, "i");
+var DEFAULT_PATTERN = /\w/;
+var DEFAULT_LENGTH = 12;
+var MIN_ENTROPY_BITS = 64;
+var MIN_WORD_LENGTH = 3;
+var MAX_WORD_LENGTH = 7;
+var MIN_MEMORABLE_LENGTH = (() => {
+  let bits = 0;
+  let len = 0;
+  let vowel = false;
+  while (bits < MIN_ENTROPY_BITS) {
+    bits += Math.log2(vowel ? VOWELS.length : CONSONANTS.length);
+    vowel = !vowel;
+    len += 1;
+  }
+  return len;
+})();
+var ensureCrypto = () => {
+  if (!cryptoSource) {
+    throw new Error("WebCrypto is required for password generation");
+  }
+  return cryptoSource;
+};
+var getRandomBytesSync = (length) => {
+  if (!Number.isFinite(length) || length < 0) {
+    throw new RangeError("length must be a non-negative finite number");
+  }
+  const crypto = ensureCrypto();
+  const buffer = new Uint8Array(length);
+  for (let offset = 0; offset < length; offset += MAX_RANDOM_BYTES) {
+    const end = Math.min(offset + MAX_RANDOM_BYTES, length);
+    crypto.getRandomValues(buffer.subarray(offset, end));
+  }
+  return buffer;
+};
+var getRandomBytes = async (length) => getRandomBytesSync(length);
+var createDeterministicRandomBytes = async (entropy, source = ensureCrypto()) => {
+  if (entropy.length === 0) {
+    throw new RangeError("entropy must not be empty");
+  }
+  if (!source.subtle) {
+    throw new Error("WebCrypto subtle is required for deterministic entropy");
+  }
+  const keyData = new Uint8Array(entropy).buffer;
+  const key = await source.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  let counter = 0n;
+  const counterBytes = new Uint8Array(8);
+  const counterView = new DataView(counterBytes.buffer);
+  const deterministicRandomBytes = async (length) => {
+    if (!Number.isFinite(length) || length < 0) {
+      throw new RangeError("length must be a non-negative finite number");
+    }
+    const buffer = new Uint8Array(length);
+    let offset = 0;
+    while (offset < length) {
+      counterView.setBigUint64(0, counter, false);
+      counter += 1n;
+      const block = new Uint8Array(
+        await source.subtle.sign("HMAC", key, counterBytes)
+      );
+      const take = Math.min(block.length, length - offset);
+      buffer.set(block.subarray(0, take), offset);
+      offset += take;
+    }
+    return buffer;
+  };
+  return deterministicRandomBytes;
+};
+var randomIntSync = (min, max, randomBytes = getRandomBytesSync) => {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    throw new RangeError("min and max must be finite numbers");
+  }
+  if (max <= min) {
+    throw new RangeError("max must be greater than min");
+  }
+  const range = max - min;
+  if (range === 1) {
+    return min;
+  }
+  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
+  const maxValue = 256 ** bytesNeeded;
+  const limit = maxValue - maxValue % range;
+  let value = limit;
+  while (value >= limit) {
+    const bytes = randomBytes(bytesNeeded);
+    value = 0;
+    for (const byte of bytes) {
+      value = value * 256 + byte;
+    }
+  }
+  return min + value % range;
+};
+var randomInt = async (min, max, randomBytes = getRandomBytes) => {
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    throw new RangeError("min and max must be finite numbers");
+  }
+  if (max <= min) {
+    throw new RangeError("max must be greater than min");
+  }
+  const range = max - min;
+  if (range === 1) {
+    return min;
+  }
+  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
+  const maxValue = 256 ** bytesNeeded;
+  const limit = maxValue - maxValue % range;
+  let value = limit;
+  while (value >= limit) {
+    const bytes = await randomBytes(bytesNeeded);
+    value = 0;
+    for (const byte of bytes) {
+      value = value * 256 + byte;
+    }
+  }
+  return min + value % range;
+};
+var buildValidChars = (pattern) => {
+  const chars = [];
+  for (let i = 33; i <= 126; i += 1) {
+    const char = String.fromCharCode(i);
+    if (pattern.test(char)) {
+      chars.push(char);
+    }
+  }
+  if (chars.length === 0) {
+    throw new Error(
+      `Could not find characters that match the password pattern ${pattern}. Patterns must match individual characters, not the password as a whole.`
+    );
+  }
+  return chars;
+};
+var estimatePatternEntropy = (alphabetSize, length, prefixLength) => {
+  const bitsPerChar = alphabetSize > 1 ? Math.log2(alphabetSize) : 0;
+  return {
+    entropyBits: bitsPerChar * Math.max(0, length - prefixLength),
+    recommendedLength: bitsPerChar > 0 ? prefixLength + Math.ceil(MIN_ENTROPY_BITS / bitsPerChar) : null
+  };
+};
+var estimateMemorableEntropy = (length, prefix) => {
+  const effectiveLength = Math.max(0, length - prefix.length);
+  let entropyBits = 0;
+  let expectsVowel = CONSONANT.test(prefix);
+  for (let i = 0; i < effectiveLength; i += 1) {
+    entropyBits += Math.log2(expectsVowel ? VOWELS.length : CONSONANTS.length);
+    expectsVowel = !expectsVowel;
+  }
+  let recommendedLength = prefix.length;
+  let bits = 0;
+  expectsVowel = CONSONANT.test(prefix);
+  while (bits < MIN_ENTROPY_BITS) {
+    bits += Math.log2(expectsVowel ? VOWELS.length : CONSONANTS.length);
+    expectsVowel = !expectsVowel;
+    recommendedLength += 1;
+  }
+  return { entropyBits, recommendedLength };
+};
+var buildMemorableSync = (length, startsWithVowel, nextInt) => {
+  let expectsVowel = startsWithVowel;
+  let result = "";
+  for (let i = 0; i < length; i += 1) {
+    const alphabet = expectsVowel ? VOWELS : CONSONANTS;
+    result += alphabet[nextInt(0, alphabet.length)];
+    expectsVowel = !expectsVowel;
+  }
+  return result;
+};
+var buildMemorable = async (length, startsWithVowel, nextInt) => {
+  let expectsVowel = startsWithVowel;
+  let result = "";
+  for (let i = 0; i < length; i += 1) {
+    const alphabet = expectsVowel ? VOWELS : CONSONANTS;
+    result += alphabet[await nextInt(0, alphabet.length)];
+    expectsVowel = !expectsVowel;
+  }
+  return result;
+};
+var buildWordLengths = async (count, nextInt, targetLength) => {
+  const lengths = [];
+  let total = 0;
+  for (let i = 0; i < count; i += 1) {
+    const len = await nextInt(MIN_WORD_LENGTH, MAX_WORD_LENGTH + 1);
+    lengths.push(len);
+    total += len;
+  }
+  if (targetLength !== void 0 && total < targetLength) {
+    const adjustable = [];
+    for (let i = 0; i < count; i += 1) {
+      if (lengths[i] < MAX_WORD_LENGTH) adjustable.push(i);
+    }
+    let remaining = targetLength - total;
+    while (remaining > 0 && adjustable.length > 0) {
+      const pick2 = await nextInt(0, adjustable.length);
+      const wordIdx = adjustable[pick2];
+      lengths[wordIdx] = lengths[wordIdx] + 1;
+      remaining -= 1;
+      if (lengths[wordIdx] >= MAX_WORD_LENGTH) {
+        adjustable.splice(pick2, 1);
+      }
+    }
+  }
+  return lengths;
+};
+var parseEntropy = (entropy) => {
+  if (typeof entropy === "string") {
+    if (textEncoder) return textEncoder.encode(entropy);
+    if (typeof Buffer !== "undefined") return Buffer.from(entropy, "utf8");
+    throw new Error("TextEncoder is required for entropy strings");
+  }
+  if (entropy instanceof Uint8Array) {
+    return entropy;
+  }
+  throw new TypeError("entropy must be a Uint8Array or string");
+};
+var validateOptions = (options) => {
+  const length = options?.length ?? DEFAULT_LENGTH;
+  const memorable = options?.memorable ?? false;
+  const pattern = options?.pattern ?? DEFAULT_PATTERN;
+  const prefix = String(options?.prefix ?? "");
+  const ignoreSecurityRecommendations = options?.ignoreSecurityRecommendations ?? false;
+  const words = options?.words;
+  if (!Number.isSafeInteger(length)) {
+    throw new RangeError("length must be a safe integer");
+  }
+  if (length < 0) {
+    throw new RangeError("length must be a non-negative integer");
+  }
+  if (!(pattern instanceof RegExp)) {
+    throw new TypeError("pattern must be a RegExp");
+  }
+  if (words !== void 0) {
+    if (!Number.isSafeInteger(words)) {
+      throw new RangeError("words must be a safe integer");
+    }
+    if (words <= 0) {
+      throw new RangeError("words must be a positive integer");
+    }
+  }
+  if (words !== void 0 && prefix !== "") {
+    throw new Error("prefix is not supported when words are enabled");
+  }
+  return {
+    length,
+    memorable,
+    pattern,
+    prefix,
+    ignoreSecurityRecommendations,
+    words
+  };
+};
+var generatePasswordSync = (options) => {
+  const {
+    length,
+    memorable,
+    pattern,
+    prefix,
+    ignoreSecurityRecommendations,
+    words
+  } = validateOptions(options);
+  if (words !== void 0) {
+    throw new Error("words requires async password generation");
+  }
+  const nextInt = (min, max) => randomIntSync(min, max, getRandomBytesSync);
+  if (memorable) {
+    if (!ignoreSecurityRecommendations) {
+      const estimate = estimateMemorableEntropy(length, prefix);
+      if (estimate.entropyBits < MIN_ENTROPY_BITS) {
+        throw new Error(
+          `Security recommendation: estimated entropy ${estimate.entropyBits.toFixed(
+            1
+          )} bits is below ${MIN_ENTROPY_BITS} bits. Use length >= ${estimate.recommendedLength} or set memorable: false. To override, pass { ignoreSecurityRecommendations: true }.`
+        );
+      }
+    }
+    const charCount = Math.max(0, length - prefix.length);
+    return prefix + buildMemorableSync(charCount, CONSONANT.test(prefix), nextInt);
+  }
+  const validChars = buildValidChars(pattern);
+  if (!ignoreSecurityRecommendations) {
+    const estimate = estimatePatternEntropy(
+      validChars.length,
+      length,
+      prefix.length
+    );
+    if (estimate.entropyBits < MIN_ENTROPY_BITS) {
+      const recommendation = estimate.recommendedLength === null ? "Use a broader pattern to increase the character set." : `Use length >= ${estimate.recommendedLength} or broaden the pattern.`;
+      throw new Error(
+        `Security recommendation: estimated entropy ${estimate.entropyBits.toFixed(
+          1
+        )} bits is below ${MIN_ENTROPY_BITS} bits. ${recommendation} To override, pass { ignoreSecurityRecommendations: true }.`
+      );
+    }
+  }
+  let result = prefix;
+  while (result.length < length) {
+    result += validChars[nextInt(0, validChars.length)];
+  }
+  return result;
+};
+var generatePasswordAsync = async (options) => {
+  const {
+    length,
+    memorable,
+    pattern,
+    prefix,
+    ignoreSecurityRecommendations,
+    words
+  } = validateOptions(options);
+  const entropy = options?.entropy;
+  let entropyBytes;
+  if (entropy !== void 0) {
+    entropyBytes = parseEntropy(entropy);
+  }
+  const randomBytes = entropyBytes ? await createDeterministicRandomBytes(entropyBytes) : getRandomBytes;
+  const nextInt = (min, max) => randomInt(min, max, randomBytes);
+  if (words !== void 0) {
+    if (!ignoreSecurityRecommendations && words * MAX_WORD_LENGTH < MIN_MEMORABLE_LENGTH) {
+      const recommendedWords = Math.ceil(
+        MIN_MEMORABLE_LENGTH / MAX_WORD_LENGTH
+      );
+      throw new Error(
+        `Security recommendation: word count ${words} cannot reach ${MIN_ENTROPY_BITS} bits with ${MIN_WORD_LENGTH}-${MAX_WORD_LENGTH} letter words. Use words >= ${recommendedWords}. To override, pass { ignoreSecurityRecommendations: true }.`
+      );
+    }
+    const targetLength = ignoreSecurityRecommendations ? void 0 : MIN_MEMORABLE_LENGTH;
+    const lengths = await buildWordLengths(words, nextInt, targetLength);
+    const wordsList = [];
+    for (const wordLength of lengths) {
+      wordsList.push(await buildMemorable(wordLength, false, nextInt));
+    }
+    return wordsList.join(" ");
+  }
+  if (memorable) {
+    if (!ignoreSecurityRecommendations) {
+      const estimate = estimateMemorableEntropy(length, prefix);
+      if (estimate.entropyBits < MIN_ENTROPY_BITS) {
+        throw new Error(
+          `Security recommendation: estimated entropy ${estimate.entropyBits.toFixed(
+            1
+          )} bits is below ${MIN_ENTROPY_BITS} bits. Use length >= ${estimate.recommendedLength} or set memorable: false. To override, pass { ignoreSecurityRecommendations: true }.`
+        );
+      }
+    }
+    const charCount = Math.max(0, length - prefix.length);
+    return prefix + await buildMemorable(charCount, CONSONANT.test(prefix), nextInt);
+  }
+  const validChars = buildValidChars(pattern);
+  if (!ignoreSecurityRecommendations) {
+    const estimate = estimatePatternEntropy(
+      validChars.length,
+      length,
+      prefix.length
+    );
+    if (estimate.entropyBits < MIN_ENTROPY_BITS) {
+      const recommendation = estimate.recommendedLength === null ? "Use a broader pattern to increase the character set." : `Use length >= ${estimate.recommendedLength} or broaden the pattern.`;
+      throw new Error(
+        `Security recommendation: estimated entropy ${estimate.entropyBits.toFixed(
+          1
+        )} bits is below ${MIN_ENTROPY_BITS} bits. ${recommendation} To override, pass { ignoreSecurityRecommendations: true }.`
+      );
+    }
+  }
+  let result = prefix;
+  while (result.length < length) {
+    result += validChars[await nextInt(0, validChars.length)];
+  }
+  return result;
+};
+function generatePassword(lengthOrOptions, memorable, pattern, prefix) {
+  if (typeof lengthOrOptions === "object") {
+    const options2 = lengthOrOptions;
+    const requiresAsync = options2.words !== void 0 || options2.entropy !== void 0;
+    return requiresAsync ? generatePasswordAsync(options2) : generatePasswordSync(options2);
+  }
+  const options = {};
+  if (lengthOrOptions !== void 0) options.length = lengthOrOptions;
+  if (memorable !== void 0) options.memorable = memorable;
+  if (pattern !== void 0) options.pattern = pattern;
+  if (prefix !== void 0) options.prefix = prefix;
+  return generatePasswordSync(options);
+}
+var generatePasswordWithOptions = (options) => {
+  const requiresAsync = options?.words !== void 0 || options?.entropy !== void 0;
+  return requiresAsync ? generatePasswordAsync(options) : generatePasswordSync(options);
+};
+
+// src/utils/sms.ts
+var GSM_7BIT_REGEXP = /^[@£$¥èéùìòÇ\nØø\rÅåΔ_ΦΓΛΩΠΨΣΘΞÆæßÉ !"#¤%&'()*+,\-./0123456789:;<=>?¡ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÑܧ¿abcdefghijklmnopqrstuvwxyzäöñüà]*$/;
+var GSM_7BIT_EXT_REGEXP = /^[@£$¥èéùìòÇ\nØø\rÅåΔ_ΦΓΛΩΠΨΣΘΞÆæßÉ !"#¤%&'()*+,\-./0123456789:;<=>?¡ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÑܧ¿abcdefghijklmnopqrstuvwxyzäöñüà\^{}\\\[\]~|€]*$/;
+var GSM_7BIT_EXT_CHAR_REGEXP = /[\^{}\\\[\]~|€]/g;
+var messageLength = {
+  GSM_7BIT: 160,
+  GSM_7BIT_EXT: 160,
+  UTF16: 70
+};
+var multiMessageLength = {
+  GSM_7BIT: 153,
+  GSM_7BIT_EXT: 153,
+  UTF16: 67
+};
+var detectEncoding = (text) => {
+  if (GSM_7BIT_REGEXP.test(text)) {
+    return "GSM_7BIT";
+  }
+  if (GSM_7BIT_EXT_REGEXP.test(text)) {
+    return "GSM_7BIT_EXT";
+  }
+  return "UTF16";
+};
+var smsLength = (text, singleOverrides, multiOverrides) => {
+  const singleLengths = { ...messageLength, ...singleOverrides };
+  const multiLengths = { ...multiMessageLength, ...multiOverrides };
+  if (text.length === 0) {
+    return {
+      encoding: "GSM_7BIT",
+      length: 0,
+      characterPerMessage: singleLengths.GSM_7BIT,
+      inCurrentMessage: 0,
+      remaining: singleLengths.GSM_7BIT,
+      messages: 0
+    };
+  }
+  const encoding = detectEncoding(text);
+  const extCharCount = encoding === "GSM_7BIT_EXT" ? (text.match(GSM_7BIT_EXT_CHAR_REGEXP) ?? []).length : 0;
+  const length = text.length + extCharCount;
+  let characterPerMessage = singleLengths[encoding];
+  if (length > characterPerMessage) {
+    characterPerMessage = multiLengths[encoding];
+  }
+  const messages = Math.ceil(length / characterPerMessage);
+  const inCurrentMessage = length - characterPerMessage * (messages - 1);
+  const remaining = characterPerMessage * messages - length;
+  return {
+    encoding,
+    length,
+    characterPerMessage,
+    inCurrentMessage,
+    remaining,
+    messages
+  };
+};
+
 // src/index.ts
 var isBrowser = typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
 var isNode = typeof process !== "undefined" && !!process.versions?.node;
 
-export { addSpaceBetweenNumbers, addThousandsSpace, areArraysDeepEqualUnordered, areArraysEqual, assessSecurityRisks, basicSanitize, capitalizeFirst, capitalizeWords, checkMarkdownSecurity, chunk, clamp, cleanObject, compact, currencyToSymbol, debounce, deburr, decodeBase36Code, decodeObject, decodeString, deferAfterResponse, deferAfterResponseNonCritical, deferNonCritical, deferPostReturn, delay, difference, encodeBase36Code, encodeObject, encodeString, fill, flatten, flattenDepth, flattenDepthBase, flattenOnce, formatBytes, formatCurrency, formatCurrencyPro, formatDecimalNumber, getStringSimilarity, groupBy, hasNilOrEmpty, humanFileSize, intersection, isBrowser, isFlattenable, isNil, isNilEmptyOrEmptyObject, isNilEmptyOrZeroLen, isNilEmptyOrZeroLength, isNilOrEmpty, isNilOrNaN, isNilOrZeroLen, isNilOrZeroLength, isNilText, isNilTextOrEmpty, isNode, isNullOrUndefined, isNullOrUndefinedEmptyOrZero, isNullOrUndefinedInArray, isNullOrUndefinedOrNaN, isNullOrUndefinedTextInc, isNullUndefinedOrEmpty, isNullUndefinedOrEmptyEnforced, isNullUndefinedOrZero, isPTTaxId, isValidIBAN, isValidPTTaxId, numbersEqual, objectToString, omit, otp, parseName, parseToBool, parseToNumber, pick, pluck, pushAll, randomDigits, removeDiacritics, round, safeAdd, safeDivide, safeJSONParse, safeMultiply, safeParseFloat, safeParseInt, safeSubtract, sanitize, sanitizeMarkdown, sentenceCase, shuffle, slugify, sortBy, stringSimilarity, symbolToCurrency, throttle, toBool, toInteger, toNumber, uniq, uniqBy };
+export { GSM_7BIT_EXT_CHAR_REGEXP, GSM_7BIT_EXT_REGEXP, GSM_7BIT_REGEXP, addSpaceBetweenNumbers, addThousandsSpace, areArraysDeepEqualUnordered, areArraysEqual, assessSecurityRisks, basicSanitize, capitalizeFirst, capitalizeWords, checkMarkdownSecurity, chunk, clamp, cleanObject, compact, currencyToSymbol, debounce, deburr, decodeBase36Code, decodeObject, decodeString, deferAfterResponse, deferAfterResponseNonCritical, deferNonCritical, deferPostReturn, delay, difference, encodeBase36Code, encodeObject, encodeString, fill, flatten, flattenDepth, flattenDepthBase, flattenOnce, formatBytes, formatCurrency, formatCurrencyPro, formatDecimalNumber, generatePassword, generatePasswordWithOptions, getStringSimilarity, groupBy, hasNilOrEmpty, humanFileSize, intersection, isBrowser, isFlattenable, isNil, isNilEmptyOrEmptyObject, isNilEmptyOrZeroLen, isNilEmptyOrZeroLength, isNilOrEmpty, isNilOrNaN, isNilOrZeroLen, isNilOrZeroLength, isNilText, isNilTextOrEmpty, isNode, isNullOrUndefined, isNullOrUndefinedEmptyOrZero, isNullOrUndefinedInArray, isNullOrUndefinedOrNaN, isNullOrUndefinedTextInc, isNullUndefinedOrEmpty, isNullUndefinedOrEmptyEnforced, isNullUndefinedOrZero, isPTTaxId, isValidIBAN, isValidPTTaxId, numbersEqual, objectToString, omit, otp, parseName, parseToBool, parseToNumber, pick, pluck, pushAll, randomDigits, removeDiacritics, round, safeAdd, safeDivide, safeJSONParse, safeMultiply, safeParseFloat, safeParseInt, safeSubtract, sanitize, sanitizeMarkdown, sentenceCase, shuffle, slugify, smsLength, sortBy, stringSimilarity, symbolToCurrency, throttle, toBool, toInteger, toNumber, uniq, uniqBy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map