@utilix-tech/sdk 0.38.0 → 0.40.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Full release notes for all Utilix surfaces (browser tools, REST API, SDKs, MCP server) live at [utilix.tech/changelog](https://utilix.tech/changelog). This file tracks just this package.
 
+## 0.40.0
+- Add `calculateCashBreakdown`, `calculateChange` (cash-till-calculator): break a cash amount down into the minimum count of bills/coins from a set of denominations (largest first), or compute change owed for a payment/tender pair and its breakdown.
+- Add `generateEtag` (etag-generator): compute a content-hash ETag (MD5/SHA-1/SHA-256) for a response header, with an optional weak-validator (W/) prefix.
+
+## 0.39.0
+- Add `generateSri`, `generateSriAll` (sri-hash-generator): compute SHA-256/384/512 Subresource Integrity hashes for a script or stylesheet's content, formatted as the `<algorithm>-<base64>` string an HTML `integrity` attribute expects.
+- Add `analyzeEmailHeaders` (email-header-analyzer): parse a raw email header block into structured From/To/Subject fields, the Received hop chain in order, and SPF/DKIM/DMARC results from an Authentication-Results header.
+
 ## 0.38.0
 - Add `compareUnitPrices` (unit-price-comparator): compare two or more package options by price and quantity to find the true cost per unit, flag the cheapest, and report how much more expensive each other option is by percentage.
 - Add `csvToSqlInsert` (csv-to-sql-insert-generator): convert CSV data with a header row into parameterless SQL INSERT statements, with basic type inference (numbers/booleans unquoted, empty cells NULL) and ANSI/MySQL identifier quoting.

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/sdk
 
-**606 developer utility functions for Node.js: runs locally, no API key required.**
+**610 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)
@@ -119,7 +119,7 @@ base62Encode("hello world");      // "AAwf93rvy4aWQVw"
 ### `/hashing`: Hash & Password
 
 ```ts
-import { hashAll, hashOne, hashPassword, verifyPassword, generateHtpasswdFile } from "@utilix-tech/sdk/hashing";
+import { hashAll, hashOne, hashPassword, verifyPassword, generateHtpasswdFile, generateSriAll } from "@utilix-tech/sdk/hashing";
 
 // Hash with MD5, SHA-1, SHA-256, SHA-512 in one call
 const hashes = await hashAll("my-string");
@@ -131,6 +131,14 @@ const valid = await verifyPassword("my-password", hash);
 
 // Generate .htpasswd file
 generateHtpasswdFile([{ username: "alice", password: "secret" }]);
+
+// Subresource Integrity hashes for a script/stylesheet's content (SHA-256/384/512)
+generateSriAll("console.log(1)");
+// [{ algorithm: "SHA-256", base64: "...", integrity: "sha256-..." }, ...]
+
+// Content-hash ETag header value (MD5/SHA-1/SHA-256), with an optional weak (W/) prefix
+generateEtag("console.log(1)");
+// { algorithm: "SHA-1", weak: false, hash: "...", etag: "\"...\"", snippet: "ETag: \"...\"" }
 ```
 
 ---
@@ -402,6 +410,14 @@ calculateRoi({ initialValue: 1000, finalValue: 1610.51, years: 5 });
 // Unit price comparator: true cost per unit across package options, flags the cheapest
 compareUnitPrices([{ label: "12-pack", price: 6, quantity: 12 }, { label: "24-pack", price: 10, quantity: 24 }]);
 // { items: [...], bestLabel: "24-pack" }
+
+// Cash till breakdown: minimum count of bills/coins from a set of denominations
+calculateCashBreakdown(53.75, USD_DENOMINATIONS);
+// { breakdown: [{ denomination: 50, count: 1, subtotal: 50 }, ...], totalCount: 7, remainder: 0 }
+
+// Change owed for a payment/tender pair, broken down the same way
+calculateChange(4.65, 5.0, USD_DENOMINATIONS);
+// { changeDue: 0.35, breakdown: [{ denomination: 0.25, count: 1, subtotal: 0.25 }, ...], totalCount: 2 }
 ```
 
 ---
@@ -412,7 +428,7 @@ compareUnitPrices([{ label: "12-pack", price: 6, quantity: 12 }, { label: "24-pa
 import { getStatusCode, isValidIp, isValidIpv4, isValidIpv6,
          searchStatusCodes, buildGeoUrl, countryCodeToFlag,
          parseHar, validateSitemap, validateRobotsTxt,
-         parseUserAgent, buildCacheControl, buildReferrerPolicy, parseIpv6Address, buildLinkHeader, checkSetCookieHeader } from "@utilix-tech/sdk/network";
+         parseUserAgent, buildCacheControl, buildReferrerPolicy, parseIpv6Address, buildLinkHeader, checkSetCookieHeader, analyzeEmailHeaders } from "@utilix-tech/sdk/network";
 
 getStatusCode(404);
 // { code: 404, text: "Not Found", description: "...", category: "Client Error" }
@@ -463,6 +479,10 @@ buildLinkHeader([{ url: "/fonts/inter.woff2", rel: "preload", as: "font", type:
 // Parse and validate a Set-Cookie header's attribute combination
 checkSetCookieHeader("session=abc123; SameSite=None");
 // { cookie: {...}, issues: ["SameSite=None requires the Secure attribute..."], warnings: [...], valid: false }
+
+// Parse a raw email header block: fields, Received hop chain, SPF/DKIM/DMARC results
+analyzeEmailHeaders(rawHeaderText);
+// { from: "...", to: "...", receivedHops: [...], hopCount: 2, spf: "pass", dkim: "pass", dmarc: "pass", warnings: [] }
 ```
 
 ---
@@ -695,12 +715,12 @@ readVideoInfo(new Uint8Array(videoBytes));
 |---|---|
 | `@utilix-tech/sdk/json` | Format, minify, diff, validate, JSONPath, CSV↔JSON, YAML↔JSON, TS types from data or from a JSON Schema |
 | `@utilix-tech/sdk/encoding` | Base64, URL, HTML entities, Base32/Base58/Base62 encode/decode |
-| `@utilix-tech/sdk/hashing` | MD5, SHA-1/256/512, bcrypt, HMAC, .htpasswd |
+| `@utilix-tech/sdk/hashing` | MD5, SHA-1/256/512, bcrypt, HMAC, .htpasswd, SRI hashes, content-hash ETag generation |
 | `@utilix-tech/sdk/text` | Case convert, slugify, word count, lorem ipsum, line ops, HTML→Markdown, Levenshtein/Damerau string distance, readability scoring, sentence length distribution, emoji lookup |
 | `@utilix-tech/sdk/data` | CSV, YAML, TOML, XML, INI, NDJSON parse and convert, SRT/WebVTT subtitles, Markdown front matter parser |
 | `@utilix-tech/sdk/generators` | UUID v4/v7, ULID, passwords, strength check, entropy estimator, fake data |
 | `@utilix-tech/sdk/time` | Date diff, timezone convert, cron parse, relative time |
-| `@utilix-tech/sdk/units` | Bytes, CSS px/rem, number bases, currency format, credit card/IBAN/barcode/ISBN validation, loan calculator, EMI calculator, compound/simple interest calculators, VAT/sales tax calculator, tip/bill split calculator, break-even point calculator, Rule of 72 calculator, savings goal calculator, ROI calculator |
+| `@utilix-tech/sdk/units` | Bytes, CSS px/rem, number bases, currency format, credit card/IBAN/barcode/ISBN validation, loan calculator, EMI calculator, compound/simple interest calculators, VAT/sales tax calculator, tip/bill split calculator, break-even point calculator, Rule of 72 calculator, savings goal calculator, ROI calculator, cash denomination/till calculator |
 | `@utilix-tech/sdk/network` | HTTP status codes, IP validation, country flags, geolocation URLs, HAR file parsing, User-Agent parsing, IPv6 address compress/expand |
 | `@utilix-tech/sdk/api` | cURL build/parse, JWT decode/sign, JWKS parse, CORS headers, CSP header |
 | `@utilix-tech/sdk/code` | SQL format/minify, HTML format/minify, regex tester, GraphQL format, MIME type lookup, GitHub URL parsing, regex ReDoS detector, Conventional Commits linter |

package/dist/{chunk-47RI5V3B.js → chunk-2MTHD2LG.js}

@@ -14,12 +14,15 @@ __export(units_exports, {
   COMMON_TAX_RATES: () => COMMON_TAX_RATES,
   COMMON_TIP_PERCENTAGES: () => COMMON_TIP_PERCENTAGES,
   COMMON_VIEWPORTS: () => COMMON_VIEWPORTS,
+  USD_DENOMINATIONS: () => USD_DENOMINATIONS,
   applySuccessiveDiscounts: () => applySuccessiveDiscounts,
   autoFormat: () => autoFormat,
   bumpVersion: () => bumpVersion,
   calcAspectRatio: () => calcAspectRatio,
   calcSubnet: () => calcSubnet,
   calculateBreakEven: () => calculateBreakEven,
+  calculateCashBreakdown: () => calculateCashBreakdown,
+  calculateChange: () => calculateChange,
   calculateCompoundInterest: () => calculateCompoundInterest,
   calculateDiscount: () => calculateDiscount,
   calculateEmi: () => calculateEmi,
@@ -1867,5 +1870,63 @@ function compareUnitPrices(items) {
   const bestLabel = results.find((r) => r.isBest).label;
   return { items: results, bestLabel };
 }
+var USD_DENOMINATIONS = [100, 50, 20, 10, 5, 1, 0.25, 0.1, 0.05, 0.01];
+function _cashToCents(n) {
+  return Math.round(n * 100);
+}
+function calculateCashBreakdown(amount, denominations) {
+  if (!Number.isFinite(amount) || amount < 0) return { error: "Amount must be zero or a positive number" };
+  if (!Array.isArray(denominations) || denominations.length === 0) {
+    return { error: "At least one denomination is required" };
+  }
+  for (const d of denominations) {
+    if (typeof d !== "number" || !Number.isFinite(d) || d <= 0) {
+      return { error: "Each denomination must be a positive number" };
+    }
+  }
+  const round22 = (n) => Math.round(n * 100) / 100;
+  const sorted = Array.from(new Set(denominations)).sort((a, b) => b - a);
+  let remainingCents = _cashToCents(amount);
+  const breakdown = [];
+  let totalCount = 0;
+  for (const d of sorted) {
+    const dCents = _cashToCents(d);
+    const count = Math.floor(remainingCents / dCents);
+    if (count > 0) {
+      breakdown.push({ denomination: d, count, subtotal: round22(count * d) });
+      remainingCents -= count * dCents;
+      totalCount += count;
+    }
+  }
+  return {
+    amount: round22(amount),
+    denominations: sorted,
+    breakdown,
+    totalCount,
+    remainder: round22(remainingCents / 100)
+  };
+}
+function calculateChange(amountDue, amountTendered, denominations) {
+  if (!Number.isFinite(amountDue) || amountDue < 0) return { error: "Amount due must be zero or a positive number" };
+  if (!Number.isFinite(amountTendered) || amountTendered < 0) {
+    return { error: "Amount tendered must be zero or a positive number" };
+  }
+  if (_cashToCents(amountTendered) < _cashToCents(amountDue)) {
+    return { error: "Amount tendered must be greater than or equal to the amount due" };
+  }
+  const round22 = (n) => Math.round(n * 100) / 100;
+  const changeDue = round22(amountTendered - amountDue);
+  const breakdown = calculateCashBreakdown(changeDue, denominations);
+  if ("error" in breakdown) return breakdown;
+  return {
+    amountDue: round22(amountDue),
+    amountTendered: round22(amountTendered),
+    changeDue,
+    denominations: breakdown.denominations,
+    breakdown: breakdown.breakdown,
+    totalCount: breakdown.totalCount,
+    remainder: breakdown.remainder
+  };
+}
 
-export { BASE_LABELS, BASE_PREFIXES, BYTE_UNITS, COMMON_CURRENCIES, COMMON_LOCALES, COMMON_PERMISSIONS, COMMON_RATIOS, COMMON_SIZES, COMMON_TAX_RATES, COMMON_TIP_PERCENTAGES, COMMON_VIEWPORTS, applySuccessiveDiscounts, autoFormat, bumpVersion, calcAspectRatio, calcSubnet, calculateBreakEven, calculateCompoundInterest, calculateDiscount, calculateEmi, calculateLoan, calculateMarginMarkup, calculatePercentageChange, calculateRoi, calculateRuleOf72, calculateSavingsGoal, calculateSimpleInterest, calculateTax, calculateTimeValue, calculateTipSplit, calculateVideoBitrate, compareSemver, compareUnitPrices, convert, convertAprApy, convertBytes, convertIp, coverBox, decimalToIp, decimalToIpCidr, describePermissions, fitIntoBox, formatNumber, formatValue, formatVwValue, formatWithSeparator, gcd, ipFromBinary, ipFromDecimal, ipFromHex, ipToBinary, ipToDecimal, ipToDecimalCidr, ipToHex, ipToOctal, isValid, isValidCidr, isValidIp, isValidIpv4, marginToMarkup, markupToMargin, octalToPermissions, parseFileSize, parseInput, parseNumberString, parseSemver, permissionsToChmod, permissionsToOctal, permissionsToSymbolic, ptToPx, pxToAll, pxToViewport, remToPx, satisfiesRange, scaleByHeight, scaleByWidth, sortVersions, splitSubnet, symbolicToPermissions, units_exports, validateBarcode, validateCardNumber, validateIban, validateIsbn, viewportToPx };
+export { BASE_LABELS, BASE_PREFIXES, BYTE_UNITS, COMMON_CURRENCIES, COMMON_LOCALES, COMMON_PERMISSIONS, COMMON_RATIOS, COMMON_SIZES, COMMON_TAX_RATES, COMMON_TIP_PERCENTAGES, COMMON_VIEWPORTS, USD_DENOMINATIONS, applySuccessiveDiscounts, autoFormat, bumpVersion, calcAspectRatio, calcSubnet, calculateBreakEven, calculateCashBreakdown, calculateChange, calculateCompoundInterest, calculateDiscount, calculateEmi, calculateLoan, calculateMarginMarkup, calculatePercentageChange, calculateRoi, calculateRuleOf72, calculateSavingsGoal, calculateSimpleInterest, calculateTax, calculateTimeValue, calculateTipSplit, calculateVideoBitrate, compareSemver, compareUnitPrices, convert, convertAprApy, convertBytes, convertIp, coverBox, decimalToIp, decimalToIpCidr, describePermissions, fitIntoBox, formatNumber, formatValue, formatVwValue, formatWithSeparator, gcd, ipFromBinary, ipFromDecimal, ipFromHex, ipToBinary, ipToDecimal, ipToDecimalCidr, ipToHex, ipToOctal, isValid, isValidCidr, isValidIp, isValidIpv4, marginToMarkup, markupToMargin, octalToPermissions, parseFileSize, parseInput, parseNumberString, parseSemver, permissionsToChmod, permissionsToOctal, permissionsToSymbolic, ptToPx, pxToAll, pxToViewport, remToPx, satisfiesRange, scaleByHeight, scaleByWidth, sortVersions, splitSubnet, symbolicToPermissions, units_exports, validateBarcode, validateCardNumber, validateIban, validateIsbn, viewportToPx };

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

@@ -6,15 +6,20 @@ import bcrypt from 'bcryptjs';
 // src/tools/hashing.ts
 var hashing_exports = {};
 __export(hashing_exports, {
+  ETAG_ALGORITHMS: () => ETAG_ALGORITHMS,
   HASH_ALGORITHMS: () => HASH_ALGORITHMS,
   HASH_BITS: () => HASH_BITS,
   ROUND_OPTIONS: () => ROUND_OPTIONS,
+  SRI_ALGORITHMS: () => SRI_ALGORITHMS,
   createEntry: () => createEntry,
   generateBcryptHash: () => generateBcryptHash,
+  generateEtag: () => generateEtag,
   generateHtpasswdFile: () => generateHtpasswdFile,
   generateMd5Hash: () => generateMd5Hash,
   generatePlain: () => generatePlain,
   generateSha1Hash: () => generateSha1Hash,
+  generateSri: () => generateSri,
+  generateSriAll: () => generateSriAll,
   hashAll: () => hashAll,
   hashOne: () => hashOne,
   hashPassword: () => hashPassword,
@@ -247,5 +252,45 @@ function generateHtpasswdFile(entries) {
 function validateUsername(username) {
   return /^[^\s:]{1,255}$/.test(username);
 }
+var SRI_ALGORITHMS = ["SHA-256", "SHA-384", "SHA-512"];
+var SRI_NODE_ALG_MAP = {
+  "SHA-256": "sha256",
+  "SHA-384": "sha384",
+  "SHA-512": "sha512"
+};
+function generateSri(content, algorithm = "SHA-384") {
+  if (typeof content !== "string" || content.length === 0) {
+    return { error: "Content is required" };
+  }
+  if (!SRI_ALGORITHMS.includes(algorithm)) {
+    return { error: `Unknown algorithm: ${algorithm}. Must be one of ${SRI_ALGORITHMS.join(", ")}` };
+  }
+  const base64 = createHash(SRI_NODE_ALG_MAP[algorithm]).update(content, "utf8").digest("base64");
+  return { algorithm, base64, integrity: `${SRI_NODE_ALG_MAP[algorithm]}-${base64}` };
+}
+function generateSriAll(content) {
+  if (typeof content !== "string" || content.length === 0) {
+    return { error: "Content is required" };
+  }
+  return SRI_ALGORITHMS.map((alg) => generateSri(content, alg));
+}
+var ETAG_ALGORITHMS = ["MD5", "SHA-1", "SHA-256"];
+var ETAG_NODE_ALG_MAP = {
+  "MD5": "md5",
+  "SHA-1": "sha1",
+  "SHA-256": "sha256"
+};
+function generateEtag(content, algorithm = "SHA-1", weak = false) {
+  if (typeof content !== "string" || content.length === 0) {
+    return { error: "Content is required" };
+  }
+  if (!ETAG_ALGORITHMS.includes(algorithm)) {
+    return { error: `Unknown algorithm: ${algorithm}. Must be one of ${ETAG_ALGORITHMS.join(", ")}` };
+  }
+  const hash = createHash(ETAG_NODE_ALG_MAP[algorithm]).update(content, "utf8").digest("hex");
+  const quoted = `"${hash}"`;
+  const etag = weak ? `W/${quoted}` : quoted;
+  return { algorithm, weak, hash, etag, headerName: "ETag", snippet: `ETag: ${etag}` };
+}
 
-export { HASH_ALGORITHMS, HASH_BITS, ROUND_OPTIONS, createEntry, generateBcryptHash, generateHtpasswdFile, generateMd5Hash, generatePlain, generateSha1Hash, hashAll, hashOne, hashPassword, hashWithTiming, hashing_exports, parseHtpasswdFile, validateRounds, validateUsername, verifyPassword };
+export { ETAG_ALGORITHMS, HASH_ALGORITHMS, HASH_BITS, ROUND_OPTIONS, SRI_ALGORITHMS, createEntry, generateBcryptHash, generateEtag, generateHtpasswdFile, generateMd5Hash, generatePlain, generateSha1Hash, generateSri, generateSriAll, hashAll, hashOne, hashPassword, hashWithTiming, hashing_exports, parseHtpasswdFile, validateRounds, validateUsername, verifyPassword };

package/dist/{chunk-DBNTO3YO.js → chunk-Y4BVU76A.js}

@@ -8,6 +8,7 @@ __export(network_exports, {
   LINK_REL_VALUES: () => LINK_REL_VALUES,
   REFERRER_POLICY_VALUES: () => REFERRER_POLICY_VALUES,
   STATUS_CODES: () => STATUS_CODES,
+  analyzeEmailHeaders: () => analyzeEmailHeaders,
   buildCacheControl: () => buildCacheControl,
   buildDnsQueryUrl: () => buildDnsQueryUrl,
   buildGeoUrl: () => buildGeoUrl,
@@ -2130,5 +2131,83 @@ function checkSetCookieHeader(header) {
   }
   return { cookie, issues, warnings, valid: issues.length === 0 };
 }
+function analyzeEmailHeaders(raw) {
+  if (typeof raw !== "string" || !raw.trim()) {
+    return { error: "Raw email header text is required" };
+  }
+  const normalized = raw.replace(/\r\n/g, "\n");
+  const blockEnd = normalized.indexOf("\n\n");
+  const headerBlock = blockEnd === -1 ? normalized : normalized.slice(0, blockEnd);
+  const rawLines = headerBlock.split("\n");
+  const unfolded = [];
+  for (const line of rawLines) {
+    if (/^[ \t]/.test(line) && unfolded.length > 0) {
+      unfolded[unfolded.length - 1] += " " + line.trim();
+    } else if (line.trim() !== "") {
+      unfolded.push(line);
+    }
+  }
+  const headers = [];
+  for (const line of unfolded) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const name = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (!name) continue;
+    headers.push({ name, value });
+  }
+  if (headers.length === 0) {
+    return { error: 'No parseable headers found \u2014 expected lines like "From: ..." or "Received: ..."' };
+  }
+  const findFirst = (name) => headers.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value ?? null;
+  const findAll = (name) => headers.filter((h) => h.name.toLowerCase() === name.toLowerCase());
+  const receivedHops = findAll("received").map((h, i) => {
+    const fromMatch = h.value.match(/from\s+([^\s;]+(?:\s*\([^)]*\))?)/i);
+    const byMatch = h.value.match(/\bby\s+([^\s;]+)/i);
+    const segments = h.value.split(";");
+    const date = segments.length > 1 ? segments[segments.length - 1].trim() : null;
+    return {
+      index: i + 1,
+      raw: h.value,
+      from: fromMatch ? fromMatch[1].trim() : null,
+      by: byMatch ? byMatch[1].trim() : null,
+      date: date || null
+    };
+  });
+  const authResultsHeader = findFirst("authentication-results");
+  const authResults = [];
+  if (authResultsHeader) {
+    const re = /\b(spf|dkim|dmarc)=(\w+)/gi;
+    let m;
+    while ((m = re.exec(authResultsHeader)) !== null) {
+      authResults.push({ mechanism: m[1].toLowerCase(), result: m[2].toLowerCase() });
+    }
+  }
+  const findAuth = (mechanism) => authResults.find((a) => a.mechanism === mechanism)?.result ?? null;
+  const warnings = [];
+  if (receivedHops.length === 0) {
+    warnings.push("No Received headers found \u2014 this may be a partial header block rather than a full raw source.");
+  }
+  if (!authResultsHeader) {
+    warnings.push("No Authentication-Results header found \u2014 SPF/DKIM/DMARC cannot be determined from this header block alone.");
+  }
+  return {
+    headers,
+    from: findFirst("from"),
+    to: findFirst("to"),
+    subject: findFirst("subject"),
+    date: findFirst("date"),
+    messageId: findFirst("message-id"),
+    returnPath: findFirst("return-path"),
+    replyTo: findFirst("reply-to"),
+    receivedHops,
+    hopCount: receivedHops.length,
+    authResults,
+    spf: findAuth("spf"),
+    dkim: findAuth("dkim"),
+    dmarc: findAuth("dmarc"),
+    warnings
+  };
+}
 
-export { DNS_RECORD_TYPES, HTTP_HEADERS, LINK_REL_VALUES, REFERRER_POLICY_VALUES, STATUS_CODES, buildCacheControl, buildDnsQueryUrl, buildGeoUrl, buildLinkHeader, buildMapUrl, buildReferrerPolicy, checkSetCookieHeader, countryCodeToFlag, formatCoordinates, formatTtl, getByCategory, getHeader, getHeadersByCategory, getStatusByCategory, getStatusCode, isClientError, isServerError, isSuccess, isValidIp, isValidIpv4, isValidIpv6, network_exports, parseDnsResponse, parseGeoResponse, parseHar, parseIpv6Address, parseUserAgent, searchHeaders, searchStatusCodes, statusCodeToText, typeNumberToLabel, validateDomain, validateHeaderName, validateHeaderValue, validateRobotsTxt, validateSitemap };
+export { DNS_RECORD_TYPES, HTTP_HEADERS, LINK_REL_VALUES, REFERRER_POLICY_VALUES, STATUS_CODES, analyzeEmailHeaders, buildCacheControl, buildDnsQueryUrl, buildGeoUrl, buildLinkHeader, buildMapUrl, buildReferrerPolicy, checkSetCookieHeader, countryCodeToFlag, formatCoordinates, formatTtl, getByCategory, getHeader, getHeadersByCategory, getStatusByCategory, getStatusCode, isClientError, isServerError, isSuccess, isValidIp, isValidIpv4, isValidIpv6, network_exports, parseDnsResponse, parseGeoResponse, parseHar, parseIpv6Address, parseUserAgent, searchHeaders, searchStatusCodes, statusCodeToText, typeNumberToLabel, validateDomain, validateHeaderName, validateHeaderValue, validateRobotsTxt, validateSitemap };

package/dist/hashing-CJjlvqS_.d.cts

@@ -0,0 +1,127 @@
+/**
+ * @utilix/sdk — hashing module
+ *
+ * Tools covered:
+ *   - hash-generator  : hashAll, hashOne (MD5, SHA-1, SHA-256, SHA-384, SHA-512)
+ *   - bcrypt-tool     : hashPassword, verifyPassword, hashWithTiming, validateRounds
+ *   - htpasswd        : generateSha1Hash, generateMd5Hash, generateBcryptHash,
+ *                       generatePlain, createEntry, parseHtpasswdFile,
+ *                       generateHtpasswdFile, validateUsername
+ *   - sri-hash-generator: generateSri, generateSriAll (SHA-256/384/512 Subresource Integrity hashes)
+ *   - etag-generator   : generateEtag (MD5/SHA-1/SHA-256 content-hash ETag header values)
+ */
+type HashAlgorithm = 'MD5' | 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+declare const HASH_ALGORITHMS: HashAlgorithm[];
+declare const HASH_BITS: Record<HashAlgorithm, number>;
+interface HashResult {
+    algorithm: HashAlgorithm;
+    hex: string;
+    bits: number;
+}
+declare function hashAll(input: string): Promise<HashResult[]>;
+declare function hashOne(algorithm: HashAlgorithm, input: string): Promise<string>;
+declare const ROUND_OPTIONS: readonly [8, 10, 12, 14];
+declare function hashPassword(password: string, rounds?: number): Promise<string>;
+declare function verifyPassword(password: string, hash: string): Promise<boolean>;
+interface BcryptResult {
+    hash: string;
+    rounds: number;
+    timingMs: number;
+}
+declare function hashWithTiming(password: string, rounds: number): Promise<BcryptResult>;
+declare function validateRounds(rounds: number): {
+    valid: boolean;
+    warning?: string;
+};
+type HtpasswdAlgorithm = 'bcrypt' | 'sha1' | 'md5' | 'plain';
+interface HtpasswdEntry {
+    username: string;
+    hashedPassword: string;
+    algorithm: HtpasswdAlgorithm;
+    line: string;
+}
+declare function generateSha1Hash(password: string): string;
+declare function generateMd5Hash(password: string): string;
+declare function generateBcryptHash(password: string, rounds?: number): string;
+declare function generatePlain(password: string): string;
+declare function createEntry(username: string, password: string, algorithm?: HtpasswdAlgorithm): HtpasswdEntry;
+declare function parseHtpasswdFile(content: string): HtpasswdEntry[];
+declare function generateHtpasswdFile(entries: HtpasswdEntry[]): string;
+declare function validateUsername(username: string): boolean;
+type SriAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512';
+declare const SRI_ALGORITHMS: SriAlgorithm[];
+interface SriResult {
+    algorithm: SriAlgorithm;
+    base64: string;
+    integrity: string;
+}
+/**
+ * Compute a Subresource Integrity hash for the given file/script content:
+ * digest it with the chosen algorithm and base64-encode it into the
+ * `<algorithm>-<base64>` form used by an HTML `integrity` attribute.
+ */
+declare function generateSri(content: string, algorithm?: SriAlgorithm): SriResult | {
+    error: string;
+};
+/** Compute SRI hashes for all three algorithms SRI supports (SHA-256/384/512). */
+declare function generateSriAll(content: string): SriResult[] | {
+    error: string;
+};
+type EtagAlgorithm = 'MD5' | 'SHA-1' | 'SHA-256';
+declare const ETAG_ALGORITHMS: EtagAlgorithm[];
+interface EtagResult {
+    algorithm: EtagAlgorithm;
+    weak: boolean;
+    hash: string;
+    etag: string;
+    headerName: 'ETag';
+    snippet: string;
+}
+/**
+ * Compute a content-hash ETag for the given content: digest it with the
+ * chosen algorithm, hex-encode it, and quote it into the exact string an
+ * ETag response header expects, with an optional weak-validator (W/)
+ * prefix. This hashes whatever content you give it; it does not replicate
+ * any specific web server's own ETag algorithm, which is often based on
+ * file size and modification time instead of content.
+ */
+declare function generateEtag(content: string, algorithm?: EtagAlgorithm, weak?: boolean): EtagResult | {
+    error: string;
+};
+
+type hashing_BcryptResult = BcryptResult;
+declare const hashing_ETAG_ALGORITHMS: typeof ETAG_ALGORITHMS;
+type hashing_EtagAlgorithm = EtagAlgorithm;
+type hashing_EtagResult = EtagResult;
+declare const hashing_HASH_ALGORITHMS: typeof HASH_ALGORITHMS;
+declare const hashing_HASH_BITS: typeof HASH_BITS;
+type hashing_HashAlgorithm = HashAlgorithm;
+type hashing_HashResult = HashResult;
+type hashing_HtpasswdAlgorithm = HtpasswdAlgorithm;
+type hashing_HtpasswdEntry = HtpasswdEntry;
+declare const hashing_ROUND_OPTIONS: typeof ROUND_OPTIONS;
+declare const hashing_SRI_ALGORITHMS: typeof SRI_ALGORITHMS;
+type hashing_SriAlgorithm = SriAlgorithm;
+type hashing_SriResult = SriResult;
+declare const hashing_createEntry: typeof createEntry;
+declare const hashing_generateBcryptHash: typeof generateBcryptHash;
+declare const hashing_generateEtag: typeof generateEtag;
+declare const hashing_generateHtpasswdFile: typeof generateHtpasswdFile;
+declare const hashing_generateMd5Hash: typeof generateMd5Hash;
+declare const hashing_generatePlain: typeof generatePlain;
+declare const hashing_generateSha1Hash: typeof generateSha1Hash;
+declare const hashing_generateSri: typeof generateSri;
+declare const hashing_generateSriAll: typeof generateSriAll;
+declare const hashing_hashAll: typeof hashAll;
+declare const hashing_hashOne: typeof hashOne;
+declare const hashing_hashPassword: typeof hashPassword;
+declare const hashing_hashWithTiming: typeof hashWithTiming;
+declare const hashing_parseHtpasswdFile: typeof parseHtpasswdFile;
+declare const hashing_validateRounds: typeof validateRounds;
+declare const hashing_validateUsername: typeof validateUsername;
+declare const hashing_verifyPassword: typeof verifyPassword;
+declare namespace hashing {
+  export { type hashing_BcryptResult as BcryptResult, hashing_ETAG_ALGORITHMS as ETAG_ALGORITHMS, type hashing_EtagAlgorithm as EtagAlgorithm, type hashing_EtagResult as EtagResult, hashing_HASH_ALGORITHMS as HASH_ALGORITHMS, hashing_HASH_BITS as HASH_BITS, type hashing_HashAlgorithm as HashAlgorithm, type hashing_HashResult as HashResult, type hashing_HtpasswdAlgorithm as HtpasswdAlgorithm, type hashing_HtpasswdEntry as HtpasswdEntry, hashing_ROUND_OPTIONS as ROUND_OPTIONS, hashing_SRI_ALGORITHMS as SRI_ALGORITHMS, type hashing_SriAlgorithm as SriAlgorithm, type hashing_SriResult as SriResult, hashing_createEntry as createEntry, hashing_generateBcryptHash as generateBcryptHash, hashing_generateEtag as generateEtag, hashing_generateHtpasswdFile as generateHtpasswdFile, hashing_generateMd5Hash as generateMd5Hash, hashing_generatePlain as generatePlain, hashing_generateSha1Hash as generateSha1Hash, hashing_generateSri as generateSri, hashing_generateSriAll as generateSriAll, hashing_hashAll as hashAll, hashing_hashOne as hashOne, hashing_hashPassword as hashPassword, hashing_hashWithTiming as hashWithTiming, hashing_parseHtpasswdFile as parseHtpasswdFile, hashing_validateRounds as validateRounds, hashing_validateUsername as validateUsername, hashing_verifyPassword as verifyPassword };
+}
+
+export { verifyPassword as A, type BcryptResult as B, ETAG_ALGORITHMS as E, HASH_ALGORITHMS as H, ROUND_OPTIONS as R, SRI_ALGORITHMS as S, type EtagAlgorithm as a, type EtagResult as b, HASH_BITS as c, type HashAlgorithm as d, type HashResult as e, type HtpasswdAlgorithm as f, type HtpasswdEntry as g, hashing as h, type SriAlgorithm as i, type SriResult as j, createEntry as k, generateBcryptHash as l, generateEtag as m, generateHtpasswdFile as n, generateMd5Hash as o, generatePlain as p, generateSha1Hash as q, generateSri as r, generateSriAll as s, hashAll as t, hashOne as u, hashPassword as v, hashWithTiming as w, parseHtpasswdFile as x, validateRounds as y, validateUsername as z };

package/dist/hashing-CJjlvqS_.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @utilix/sdk — hashing module
+ *
+ * Tools covered:
+ *   - hash-generator  : hashAll, hashOne (MD5, SHA-1, SHA-256, SHA-384, SHA-512)
+ *   - bcrypt-tool     : hashPassword, verifyPassword, hashWithTiming, validateRounds
+ *   - htpasswd        : generateSha1Hash, generateMd5Hash, generateBcryptHash,
+ *                       generatePlain, createEntry, parseHtpasswdFile,
+ *                       generateHtpasswdFile, validateUsername
+ *   - sri-hash-generator: generateSri, generateSriAll (SHA-256/384/512 Subresource Integrity hashes)
+ *   - etag-generator   : generateEtag (MD5/SHA-1/SHA-256 content-hash ETag header values)
+ */
+type HashAlgorithm = 'MD5' | 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+declare const HASH_ALGORITHMS: HashAlgorithm[];
+declare const HASH_BITS: Record<HashAlgorithm, number>;
+interface HashResult {
+    algorithm: HashAlgorithm;
+    hex: string;
+    bits: number;
+}
+declare function hashAll(input: string): Promise<HashResult[]>;
+declare function hashOne(algorithm: HashAlgorithm, input: string): Promise<string>;
+declare const ROUND_OPTIONS: readonly [8, 10, 12, 14];
+declare function hashPassword(password: string, rounds?: number): Promise<string>;
+declare function verifyPassword(password: string, hash: string): Promise<boolean>;
+interface BcryptResult {
+    hash: string;
+    rounds: number;
+    timingMs: number;
+}
+declare function hashWithTiming(password: string, rounds: number): Promise<BcryptResult>;
+declare function validateRounds(rounds: number): {
+    valid: boolean;
+    warning?: string;
+};
+type HtpasswdAlgorithm = 'bcrypt' | 'sha1' | 'md5' | 'plain';
+interface HtpasswdEntry {
+    username: string;
+    hashedPassword: string;
+    algorithm: HtpasswdAlgorithm;
+    line: string;
+}
+declare function generateSha1Hash(password: string): string;
+declare function generateMd5Hash(password: string): string;
+declare function generateBcryptHash(password: string, rounds?: number): string;
+declare function generatePlain(password: string): string;
+declare function createEntry(username: string, password: string, algorithm?: HtpasswdAlgorithm): HtpasswdEntry;
+declare function parseHtpasswdFile(content: string): HtpasswdEntry[];
+declare function generateHtpasswdFile(entries: HtpasswdEntry[]): string;
+declare function validateUsername(username: string): boolean;
+type SriAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512';
+declare const SRI_ALGORITHMS: SriAlgorithm[];
+interface SriResult {
+    algorithm: SriAlgorithm;
+    base64: string;
+    integrity: string;
+}
+/**
+ * Compute a Subresource Integrity hash for the given file/script content:
+ * digest it with the chosen algorithm and base64-encode it into the
+ * `<algorithm>-<base64>` form used by an HTML `integrity` attribute.
+ */
+declare function generateSri(content: string, algorithm?: SriAlgorithm): SriResult | {
+    error: string;
+};
+/** Compute SRI hashes for all three algorithms SRI supports (SHA-256/384/512). */
+declare function generateSriAll(content: string): SriResult[] | {
+    error: string;
+};
+type EtagAlgorithm = 'MD5' | 'SHA-1' | 'SHA-256';
+declare const ETAG_ALGORITHMS: EtagAlgorithm[];
+interface EtagResult {
+    algorithm: EtagAlgorithm;
+    weak: boolean;
+    hash: string;
+    etag: string;
+    headerName: 'ETag';
+    snippet: string;
+}
+/**
+ * Compute a content-hash ETag for the given content: digest it with the
+ * chosen algorithm, hex-encode it, and quote it into the exact string an
+ * ETag response header expects, with an optional weak-validator (W/)
+ * prefix. This hashes whatever content you give it; it does not replicate
+ * any specific web server's own ETag algorithm, which is often based on
+ * file size and modification time instead of content.
+ */
+declare function generateEtag(content: string, algorithm?: EtagAlgorithm, weak?: boolean): EtagResult | {
+    error: string;
+};
+
+type hashing_BcryptResult = BcryptResult;
+declare const hashing_ETAG_ALGORITHMS: typeof ETAG_ALGORITHMS;
+type hashing_EtagAlgorithm = EtagAlgorithm;
+type hashing_EtagResult = EtagResult;
+declare const hashing_HASH_ALGORITHMS: typeof HASH_ALGORITHMS;
+declare const hashing_HASH_BITS: typeof HASH_BITS;
+type hashing_HashAlgorithm = HashAlgorithm;
+type hashing_HashResult = HashResult;
+type hashing_HtpasswdAlgorithm = HtpasswdAlgorithm;
+type hashing_HtpasswdEntry = HtpasswdEntry;
+declare const hashing_ROUND_OPTIONS: typeof ROUND_OPTIONS;
+declare const hashing_SRI_ALGORITHMS: typeof SRI_ALGORITHMS;
+type hashing_SriAlgorithm = SriAlgorithm;
+type hashing_SriResult = SriResult;
+declare const hashing_createEntry: typeof createEntry;
+declare const hashing_generateBcryptHash: typeof generateBcryptHash;
+declare const hashing_generateEtag: typeof generateEtag;
+declare const hashing_generateHtpasswdFile: typeof generateHtpasswdFile;
+declare const hashing_generateMd5Hash: typeof generateMd5Hash;
+declare const hashing_generatePlain: typeof generatePlain;
+declare const hashing_generateSha1Hash: typeof generateSha1Hash;
+declare const hashing_generateSri: typeof generateSri;
+declare const hashing_generateSriAll: typeof generateSriAll;
+declare const hashing_hashAll: typeof hashAll;
+declare const hashing_hashOne: typeof hashOne;
+declare const hashing_hashPassword: typeof hashPassword;
+declare const hashing_hashWithTiming: typeof hashWithTiming;
+declare const hashing_parseHtpasswdFile: typeof parseHtpasswdFile;
+declare const hashing_validateRounds: typeof validateRounds;
+declare const hashing_validateUsername: typeof validateUsername;
+declare const hashing_verifyPassword: typeof verifyPassword;
+declare namespace hashing {
+  export { type hashing_BcryptResult as BcryptResult, hashing_ETAG_ALGORITHMS as ETAG_ALGORITHMS, type hashing_EtagAlgorithm as EtagAlgorithm, type hashing_EtagResult as EtagResult, hashing_HASH_ALGORITHMS as HASH_ALGORITHMS, hashing_HASH_BITS as HASH_BITS, type hashing_HashAlgorithm as HashAlgorithm, type hashing_HashResult as HashResult, type hashing_HtpasswdAlgorithm as HtpasswdAlgorithm, type hashing_HtpasswdEntry as HtpasswdEntry, hashing_ROUND_OPTIONS as ROUND_OPTIONS, hashing_SRI_ALGORITHMS as SRI_ALGORITHMS, type hashing_SriAlgorithm as SriAlgorithm, type hashing_SriResult as SriResult, hashing_createEntry as createEntry, hashing_generateBcryptHash as generateBcryptHash, hashing_generateEtag as generateEtag, hashing_generateHtpasswdFile as generateHtpasswdFile, hashing_generateMd5Hash as generateMd5Hash, hashing_generatePlain as generatePlain, hashing_generateSha1Hash as generateSha1Hash, hashing_generateSri as generateSri, hashing_generateSriAll as generateSriAll, hashing_hashAll as hashAll, hashing_hashOne as hashOne, hashing_hashPassword as hashPassword, hashing_hashWithTiming as hashWithTiming, hashing_parseHtpasswdFile as parseHtpasswdFile, hashing_validateRounds as validateRounds, hashing_validateUsername as validateUsername, hashing_verifyPassword as verifyPassword };
+}
+
+export { verifyPassword as A, type BcryptResult as B, ETAG_ALGORITHMS as E, HASH_ALGORITHMS as H, ROUND_OPTIONS as R, SRI_ALGORITHMS as S, type EtagAlgorithm as a, type EtagResult as b, HASH_BITS as c, type HashAlgorithm as d, type HashResult as e, type HtpasswdAlgorithm as f, type HtpasswdEntry as g, hashing as h, type SriAlgorithm as i, type SriResult as j, createEntry as k, generateBcryptHash as l, generateEtag as m, generateHtpasswdFile as n, generateMd5Hash as o, generatePlain as p, generateSha1Hash as q, generateSri as r, generateSriAll as s, hashAll as t, hashOne as u, hashPassword as v, hashWithTiming as w, parseHtpasswdFile as x, validateRounds as y, validateUsername as z };