@utilix-tech/sdk 0.5.0 → 0.7.0

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/sdk
 
-**523 developer utility functions for Node.js: runs locally, no API key required.**
+**526 developer utility functions for Node.js: runs locally, no API key required.**
 
 [![npm version](https://img.shields.io/npm/v/@utilix-tech/sdk?style=flat-square&color=cb3837)](https://www.npmjs.com/package/@utilix-tech/sdk)
 [![npm downloads](https://img.shields.io/npm/dm/@utilix-tech/sdk?style=flat-square)](https://www.npmjs.com/package/@utilix-tech/sdk)
@@ -127,7 +127,7 @@ generateHtpasswdFile([{ username: "alice", password: "secret" }]);
 
 ```ts
 import { convertCase, slugify, countWords, generateWords, generateParagraphs,
-         escapeString, htmlToMarkdown, applyOps, detectPassiveVoice } from "@utilix-tech/sdk/text";
+         escapeString, htmlToMarkdown, applyOps, detectPassiveVoice, scoreReadability } from "@utilix-tech/sdk/text";
 
 convertCase("hello world", "camelCase");   // "helloWorld"
 convertCase("hello world", "PascalCase");  // "HelloWorld"
@@ -148,6 +148,10 @@ htmlToMarkdown("<h1>Hello</h1><p>World</p>");
 
 // Flag passive-voice sentences, e.g. "was written", "were approved by the team"
 detectPassiveVoice("The report was reviewed by the committee. They approved it.");
+
+// Flesch Reading Ease, Flesch-Kincaid Grade Level, and Gunning Fog Index
+scoreReadability("The cat sat on the mat. It was a sunny day.");
+// { fleschReadingEase: 109, fleschKincaidGrade: -0.6, gunningFog: 2.2, readingLevel: "Very easy (5th grade)", ... }
 ```
 
 ---
@@ -416,10 +420,10 @@ analyzeString("café");          // { length: 4, codePoints: [...], ... }
 
 ---
 
-### `/media`: Image Header Parsing & PDF Metadata
+### `/media`: Image Header Parsing, EXIF, PDF & WAV Metadata
 
 ```ts
-import { readImageInfo, readPdfMetadata } from "@utilix-tech/sdk/media";
+import { readImageInfo, readExifData, readPdfMetadata, readWavInfo } from "@utilix-tech/sdk/media";
 
 // Reads format, dimensions, bit depth, and alpha channel straight from
 // file bytes: no decoding, no canvas, no image library.
@@ -427,14 +431,26 @@ const bytes = await fs.promises.readFile("photo.png");
 readImageInfo(new Uint8Array(bytes));
 // { format: "png", width: 1920, height: 1080, bitDepth: 8, colorType: "rgba", hasAlpha: true }
 
+// Reads camera make/model, orientation, timestamps, exposure settings, and
+// GPS coordinates directly from a JPEG's EXIF data. JPEG only.
+const jpegBytes = await fs.promises.readFile("photo.jpg");
+readExifData(new Uint8Array(jpegBytes));
+// { make: "Canon", model: "EOS R5", orientation: 1, exposureTime: "1/125", fNumber: 2.8, ... }
+
 // Reads title, author, dates, page count, and encryption flag from a PDF's
 // trailer/Info dictionary: no pdf.js or other PDF library required.
 const pdfBytes = await fs.promises.readFile("report.pdf");
 readPdfMetadata(new Uint8Array(pdfBytes));
 // { version: "1.7", pageCount: 12, title: "Q3 Report", author: "Jane Doe", ... }
+
+// Reads sample rate, channels, bit depth, and duration from a WAV file's
+// RIFF/fmt/data chunk headers: no audio library required.
+const wavBytes = await fs.promises.readFile("recording.wav");
+readWavInfo(new Uint8Array(wavBytes));
+// { audioFormat: 1, audioFormatLabel: "PCM", channels: 2, sampleRate: 44100, bitsPerSample: 16, durationSeconds: 12.4, ... }
 ```
 
-Supports PNG, JPEG, GIF, WebP, and BMP.
+`readImageInfo` supports PNG, JPEG, GIF, WebP, and BMP. `readExifData` supports JPEG only. `readWavInfo` supports the canonical RIFF/WAVE container only.
 
 ---
 
@@ -457,7 +473,7 @@ Supports PNG, JPEG, GIF, WebP, and BMP.
 | `@utilix-tech/sdk/css` | CSS gradient, box-shadow, border-radius, keyframe animation generators |
 | `@utilix-tech/sdk/misc` | SVG optimize/sanitize, file size format, Unicode inspector |
 | `@utilix-tech/sdk/ai_agent` | Token estimate/trim, chunk text, extract URLs/JSON/keywords, sanitize HTML, flatten/merge JSON, dedupe lines, validate schema, PII/secret/injection detect |
-| `@utilix-tech/sdk/media` | Image format & dimension reading from raw bytes (PNG, JPEG, GIF, WebP, BMP); PDF metadata reading |
+| `@utilix-tech/sdk/media` | Image format & dimension reading from raw bytes (PNG, JPEG, GIF, WebP, BMP); PDF metadata reading; WAV audio info |
 
 ---
 

package/dist/{chunk-WWKPLYEP.js → chunk-5CKOJXFU.js}

@@ -3,8 +3,10 @@ import { __export } from './chunk-MLKGABMK.js';
 // src/tools/media.ts
 var media_exports = {};
 __export(media_exports, {
+  readExifData: () => readExifData,
   readImageInfo: () => readImageInfo,
-  readPdfMetadata: () => readPdfMetadata
+  readPdfMetadata: () => readPdfMetadata,
+  readWavInfo: () => readWavInfo
 });
 function readU32BE(bytes, offset) {
   return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
@@ -131,6 +133,195 @@ function readImageInfo(bytes) {
   }
   return { error: "Unrecognized image format. Supported formats: PNG, JPEG, GIF, WebP, BMP" };
 }
+var ORIENTATION_LABELS = {
+  1: "Normal",
+  2: "Mirrored horizontal",
+  3: "Rotated 180\xB0",
+  4: "Mirrored vertical",
+  5: "Mirrored horizontal, rotated 90\xB0 CCW",
+  6: "Rotated 90\xB0 CW",
+  7: "Mirrored horizontal, rotated 90\xB0 CW",
+  8: "Rotated 90\xB0 CCW"
+};
+function tu16(r, o) {
+  return r.view.getUint16(o, r.little);
+}
+function tu32(r, o) {
+  return r.view.getUint32(o, r.little);
+}
+function readIfdEntries(r, ifdOffset) {
+  if (ifdOffset < 0 || ifdOffset + 2 > r.bytes.length) return null;
+  const numEntries = tu16(r, ifdOffset);
+  const entries = [];
+  for (let i = 0; i < numEntries; i++) {
+    const entryOffset = ifdOffset + 2 + i * 12;
+    if (entryOffset + 12 > r.bytes.length) break;
+    entries.push({
+      tag: tu16(r, entryOffset),
+      type: tu16(r, entryOffset + 2),
+      count: tu32(r, entryOffset + 4),
+      valueOffsetField: entryOffset + 8
+    });
+  }
+  return { entries };
+}
+function findEntry(entries, tag) {
+  return entries.find((e) => e.tag === tag);
+}
+function readAscii(r, entry) {
+  const size = entry.count;
+  const inline = size <= 4;
+  const dataOffset = inline ? entry.valueOffsetField : r.tiffStart + tu32(r, entry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + size > r.bytes.length) return null;
+  let out = "";
+  for (let i = 0; i < size; i++) {
+    const c = r.bytes[dataOffset + i];
+    if (c === 0) break;
+    out += String.fromCharCode(c);
+  }
+  const trimmed = out.trim();
+  return trimmed || null;
+}
+function readRational(r, entry) {
+  const dataOffset = r.tiffStart + tu32(r, entry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + 8 > r.bytes.length) return null;
+  return { num: tu32(r, dataOffset), den: tu32(r, dataOffset + 4) };
+}
+function readGpsCoordinate(r, entries, valueTag, refTag) {
+  const valueEntry = findEntry(entries, valueTag);
+  if (!valueEntry) return null;
+  const dataOffset = r.tiffStart + tu32(r, valueEntry.valueOffsetField);
+  if (dataOffset < 0 || dataOffset + 24 > r.bytes.length) return null;
+  const deg = tu32(r, dataOffset) / (tu32(r, dataOffset + 4) || 1);
+  const min = tu32(r, dataOffset + 8) / (tu32(r, dataOffset + 12) || 1);
+  const sec = tu32(r, dataOffset + 16) / (tu32(r, dataOffset + 20) || 1);
+  let decimal = deg + min / 60 + sec / 3600;
+  const refEntry = findEntry(entries, refTag);
+  const ref = refEntry ? readAscii(r, refEntry) : null;
+  if (ref === "S" || ref === "W") decimal = -decimal;
+  return Math.round(decimal * 1e6) / 1e6;
+}
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b);
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function formatExposureTime(num, den) {
+  if (num === 0) return "0s";
+  if (num >= den) return `${round2(num / den)}s`;
+  const divisor = gcd(num, den) || 1;
+  const n = num / divisor;
+  const d = den / divisor;
+  return `1/${Math.round(d / n)}`;
+}
+function readExifData(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) {
+    return { error: "Not a JPEG file (EXIF is only read from JPEG files)" };
+  }
+  let offset = 2;
+  let exifStart = -1;
+  while (offset + 4 <= bytes.length) {
+    if (bytes[offset] !== 255) {
+      offset++;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    if (marker === 217 || marker === 218) break;
+    const segmentLength = bytes[offset + 2] << 8 | bytes[offset + 3];
+    if (marker === 225) {
+      const idOffset = offset + 4;
+      if (idOffset + 6 <= bytes.length && bytes[idOffset] === 69 && bytes[idOffset + 1] === 120 && bytes[idOffset + 2] === 105 && bytes[idOffset + 3] === 102 && bytes[idOffset + 4] === 0 && bytes[idOffset + 5] === 0) {
+        exifStart = idOffset + 6;
+        break;
+      }
+    }
+    offset += 2 + segmentLength;
+  }
+  if (exifStart === -1) return { error: "No EXIF segment found in this JPEG" };
+  if (exifStart + 8 > bytes.length) return { error: "Truncated EXIF segment" };
+  const byteOrder = String.fromCharCode(bytes[exifStart], bytes[exifStart + 1]);
+  if (byteOrder !== "II" && byteOrder !== "MM") return { error: "Invalid TIFF byte order marker in EXIF data" };
+  const little = byteOrder === "II";
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const r = { bytes, view, little, tiffStart: exifStart };
+  if (tu16(r, exifStart + 2) !== 42) return { error: "Invalid TIFF magic number in EXIF data" };
+  const ifd0Offset = exifStart + tu32(r, exifStart + 4);
+  const ifd0 = readIfdEntries(r, ifd0Offset);
+  if (!ifd0) return { error: "Could not read IFD0 from EXIF data" };
+  const result = { tagCount: ifd0.entries.length };
+  const makeEntry = findEntry(ifd0.entries, 271);
+  if (makeEntry) {
+    const v = readAscii(r, makeEntry);
+    if (v) result.make = v;
+  }
+  const modelEntry = findEntry(ifd0.entries, 272);
+  if (modelEntry) {
+    const v = readAscii(r, modelEntry);
+    if (v) result.model = v;
+  }
+  const softwareEntry = findEntry(ifd0.entries, 305);
+  if (softwareEntry) {
+    const v = readAscii(r, softwareEntry);
+    if (v) result.software = v;
+  }
+  const dateTimeEntry = findEntry(ifd0.entries, 306);
+  if (dateTimeEntry) {
+    const v = readAscii(r, dateTimeEntry);
+    if (v) result.dateTime = v;
+  }
+  const orientEntry = findEntry(ifd0.entries, 274);
+  if (orientEntry) {
+    const v = tu16(r, orientEntry.valueOffsetField);
+    result.orientation = v;
+    result.orientationLabel = ORIENTATION_LABELS[v] ?? "Unknown";
+  }
+  const exifIfdPtr = findEntry(ifd0.entries, 34665);
+  if (exifIfdPtr) {
+    const subOffset = exifStart + tu32(r, exifIfdPtr.valueOffsetField);
+    const sub = readIfdEntries(r, subOffset);
+    if (sub) {
+      const dtoEntry = findEntry(sub.entries, 36867);
+      if (dtoEntry) {
+        const v = readAscii(r, dtoEntry);
+        if (v) result.dateTimeOriginal = v;
+      }
+      const expEntry = findEntry(sub.entries, 33434);
+      if (expEntry) {
+        const rat = readRational(r, expEntry);
+        if (rat && rat.den !== 0) result.exposureTime = formatExposureTime(rat.num, rat.den);
+      }
+      const fEntry = findEntry(sub.entries, 33437);
+      if (fEntry) {
+        const rat = readRational(r, fEntry);
+        if (rat && rat.den !== 0) result.fNumber = round2(rat.num / rat.den);
+      }
+      const isoEntry = findEntry(sub.entries, 34855);
+      if (isoEntry) result.isoSpeed = tu16(r, isoEntry.valueOffsetField);
+      const focalEntry = findEntry(sub.entries, 37386);
+      if (focalEntry) {
+        const rat = readRational(r, focalEntry);
+        if (rat && rat.den !== 0) result.focalLength = round2(rat.num / rat.den);
+      }
+    }
+  }
+  const gpsIfdPtr = findEntry(ifd0.entries, 34853);
+  if (gpsIfdPtr) {
+    const gpsOffset = exifStart + tu32(r, gpsIfdPtr.valueOffsetField);
+    const gps = readIfdEntries(r, gpsOffset);
+    if (gps) {
+      const lat = readGpsCoordinate(r, gps.entries, 2, 1);
+      const lon = readGpsCoordinate(r, gps.entries, 4, 3);
+      if (lat !== null) result.gpsLatitude = lat;
+      if (lon !== null) result.gpsLongitude = lon;
+    }
+  }
+  return result;
+}
 function bytesToLatin1(bytes) {
   let out = "";
   const CHUNK = 32768;
@@ -273,5 +464,61 @@ function readPdfMetadata(bytes) {
     encrypted
   };
 }
+var AUDIO_FORMAT_LABELS = {
+  1: "PCM",
+  3: "IEEE float",
+  6: "A-law",
+  7: "mu-law",
+  65534: "Extensible"
+};
+function readAscii4(bytes, offset) {
+  return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function readWavInfo(bytes) {
+  if (bytes.length < 12) return { error: "File is too small to be a valid WAV file" };
+  if (readAscii4(bytes, 0) !== "RIFF") return { error: 'Not a RIFF file (missing "RIFF" header)' };
+  if (readAscii4(bytes, 8) !== "WAVE") return { error: 'Not a WAVE file (missing "WAVE" format marker)' };
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const fileSize = view.getUint32(4, true) + 8;
+  let offset = 12;
+  let fmt = null;
+  let dataSize = null;
+  while (offset + 8 <= bytes.length) {
+    const chunkId = readAscii4(bytes, offset);
+    const chunkSize = view.getUint32(offset + 4, true);
+    const dataOffset = offset + 8;
+    if (chunkId === "fmt ") {
+      if (dataOffset + 16 > bytes.length) return { error: 'Truncated "fmt " chunk' };
+      fmt = {
+        audioFormat: view.getUint16(dataOffset, true),
+        channels: view.getUint16(dataOffset + 2, true),
+        sampleRate: view.getUint32(dataOffset + 4, true),
+        byteRate: view.getUint32(dataOffset + 8, true),
+        blockAlign: view.getUint16(dataOffset + 12, true),
+        bitsPerSample: view.getUint16(dataOffset + 14, true)
+      };
+    } else if (chunkId === "data") {
+      dataSize = Math.min(chunkSize, bytes.length - dataOffset);
+    }
+    offset = dataOffset + chunkSize + chunkSize % 2;
+    if (fmt && dataSize !== null) break;
+  }
+  if (!fmt) return { error: 'No "fmt " chunk found in this WAV file' };
+  if (dataSize === null) return { error: 'No "data" chunk found in this WAV file' };
+  if (fmt.byteRate <= 0) return { error: 'Invalid byte rate in "fmt " chunk' };
+  const durationSeconds = Math.round(dataSize / fmt.byteRate * 1e3) / 1e3;
+  return {
+    audioFormat: fmt.audioFormat,
+    audioFormatLabel: AUDIO_FORMAT_LABELS[fmt.audioFormat] ?? `Unknown (0x${fmt.audioFormat.toString(16)})`,
+    channels: fmt.channels,
+    sampleRate: fmt.sampleRate,
+    byteRate: fmt.byteRate,
+    blockAlign: fmt.blockAlign,
+    bitsPerSample: fmt.bitsPerSample,
+    dataSize,
+    durationSeconds,
+    fileSize
+  };
+}
 
-export { media_exports, readImageInfo, readPdfMetadata };
+export { media_exports, readExifData, readImageInfo, readPdfMetadata, readWavInfo };

package/dist/{chunk-YBBYFAOV.js → chunk-F57WMKZO.js}

@@ -51,6 +51,7 @@ __export(text_exports, {
   readabilityScore: () => readabilityScore,
   renderMarkdown: () => renderMarkdown,
   romanToNumber: () => romanToNumber,
+  scoreReadability: () => scoreReadability,
   sentenceCount: () => sentenceCount,
   slugify: () => slugify,
   slugifyAll: () => slugifyAll,
@@ -2389,5 +2390,72 @@ function detectPassiveVoice(text) {
   const passivePercent = totalSentences > 0 ? Math.round(passiveSentences / totalSentences * 1e3) / 10 : 0;
   return { sentences: analyzed, totalSentences, passiveSentences, passivePercent };
 }
+function countSyllables(word) {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (w.length === 0) return 0;
+  if (w.length <= 3) return 1;
+  let count = 0;
+  let prevWasVowel = false;
+  for (const ch of w) {
+    const isVowel = "aeiouy".includes(ch);
+    if (isVowel && !prevWasVowel) count++;
+    prevWasVowel = isVowel;
+  }
+  if (w.endsWith("e") && !w.endsWith("le") && count > 1) count--;
+  if (w.endsWith("le") && w.length > 2 && !"aeiouy".includes(w[w.length - 3])) count++;
+  return Math.max(count, 1);
+}
+function readabilityGradeLabel(fleschReadingEase) {
+  if (fleschReadingEase >= 90) return "Very easy (5th grade)";
+  if (fleschReadingEase >= 80) return "Easy (6th grade)";
+  if (fleschReadingEase >= 70) return "Fairly easy (7th grade)";
+  if (fleschReadingEase >= 60) return "Standard (8th-9th grade)";
+  if (fleschReadingEase >= 50) return "Fairly difficult (10th-12th grade)";
+  if (fleschReadingEase >= 30) return "Difficult (college)";
+  return "Very difficult (college graduate)";
+}
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+function scoreReadability(text) {
+  const sentences = splitIntoSentences(text);
+  const words = text.match(/[a-zA-Z']+/g) ?? [];
+  const sentenceCount2 = Math.max(sentences.length, 1);
+  const wordCount = words.length;
+  const syllableCounts = words.map(countSyllables);
+  const syllableCount2 = syllableCounts.reduce((a, b) => a + b, 0);
+  const complexWordCount = syllableCounts.filter((c) => c >= 3).length;
+  if (wordCount === 0) {
+    return {
+      wordCount: 0,
+      sentenceCount: 0,
+      syllableCount: 0,
+      complexWordCount: 0,
+      avgWordsPerSentence: 0,
+      avgSyllablesPerWord: 0,
+      fleschReadingEase: 0,
+      fleschKincaidGrade: 0,
+      gunningFog: 0,
+      readingLevel: "No text to score"
+    };
+  }
+  const avgWordsPerSentence = wordCount / sentenceCount2;
+  const avgSyllablesPerWord = syllableCount2 / wordCount;
+  const fleschReadingEase = round1(206.835 - 1.015 * avgWordsPerSentence - 84.6 * avgSyllablesPerWord);
+  const fleschKincaidGrade = round1(0.39 * avgWordsPerSentence + 11.8 * avgSyllablesPerWord - 15.59);
+  const gunningFog = round1(0.4 * (avgWordsPerSentence + 100 * (complexWordCount / wordCount)));
+  return {
+    wordCount,
+    sentenceCount: sentences.length,
+    syllableCount: syllableCount2,
+    complexWordCount,
+    avgWordsPerSentence: round1(avgWordsPerSentence),
+    avgSyllablesPerWord: round1(avgSyllablesPerWord),
+    fleschReadingEase,
+    fleschKincaidGrade,
+    gunningFog,
+    readingLevel: readabilityGradeLabel(fleschReadingEase)
+  };
+}
 
-export { CASE_FORMATS, DEFAULT_CONVERT_OPTIONS, ESCAPE_MODES, LINE_OPS, MORSE_CODE, addBorder, analyzeText, applyOp, applyOps, centerText, convertAll, convertCase, countWords, csvToHtml, csvToMarkdown, detectDelimiter, detectPassiveVoice, diffLines, diffLinesSimple, diffStats, escapeAll, escapeString, extractHeadings, formatReadingTime, generate, generateDiff, generateHtmlTable, generateMarkdownTable, generateParagraphs, generateSentences, generateWords, getAvailableFonts, getMorseForChar, getMorseTiming, htmlToMarkdown, isValidMorse, markdownToHtml, morseToText, numberToOrdinal, numberToRoman, numberToWords, ordinalWords, parseDiff, parseTableData, readabilityScore, renderMarkdown, romanToNumber, sentenceCount, slugify, slugifyAll, syllableCount, textToAscii, textToMorse, text_exports, unescapeString, wordFrequency };
+export { CASE_FORMATS, DEFAULT_CONVERT_OPTIONS, ESCAPE_MODES, LINE_OPS, MORSE_CODE, addBorder, analyzeText, applyOp, applyOps, centerText, convertAll, convertCase, countWords, csvToHtml, csvToMarkdown, detectDelimiter, detectPassiveVoice, diffLines, diffLinesSimple, diffStats, escapeAll, escapeString, extractHeadings, formatReadingTime, generate, generateDiff, generateHtmlTable, generateMarkdownTable, generateParagraphs, generateSentences, generateWords, getAvailableFonts, getMorseForChar, getMorseTiming, htmlToMarkdown, isValidMorse, markdownToHtml, morseToText, numberToOrdinal, numberToRoman, numberToWords, ordinalWords, parseDiff, parseTableData, readabilityScore, renderMarkdown, romanToNumber, scoreReadability, sentenceCount, slugify, slugifyAll, syllableCount, textToAscii, textToMorse, text_exports, unescapeString, wordFrequency };

package/dist/{chunk-FL53T24A.js → chunk-GEFVMGZR.js}

@@ -189,13 +189,7 @@ function generateMd5Hash(password) {
   return "$apr1$" + md5(password);
 }
 function generateBcryptHash(password, rounds = 10) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./";
-  let salt = "";
-  for (let i = 0; i < 22; i++) salt += chars[Math.floor(Math.random() * chars.length)];
-  const roundStr = rounds.toString().padStart(2, "0");
-  let hash = "";
-  for (let i = 0; i < 31; i++) hash += chars[Math.floor(Math.random() * chars.length)];
-  return `$2b$${roundStr}$${salt}${hash}`;
+  return bcrypt.hashSync(password, rounds);
 }
 function generatePlain(password) {
   return password;
@@ -204,7 +198,7 @@ function createEntry(username, password, algorithm = "bcrypt") {
   let hashedPassword;
   switch (algorithm) {
     case "bcrypt":
-      hashedPassword = generateBcryptHash();
+      hashedPassword = generateBcryptHash(password);
       break;
     case "sha1":
       hashedPassword = generateSha1Hash(password);