@utilix-tech/sdk 0.97.0 → 0.99.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.99.0
+- Add `calculateDividendYield` (dividend-yield-calculator): compute a stock's dividend yield from annual dividend per share and share price, plus payout ratio and retention ratio when trailing EPS is given.
+- Add `checkKnownHostsFingerprints` (ssh-known-hosts-fingerprint-checker): compute SHA256/MD5 fingerprints for ssh_known_hosts entries the way `ssh-keygen -lf` does, decoding key type and RSA bit length to flag weak or deprecated keys.
+
+## 0.98.0
+- Add `convertTimecode` (timecode-converter): convert between a frame count, SMPTE timecode (HH:MM:SS:FF), and seconds at a given frame rate, handling NTSC drop-frame timecode's skipped frame numbers correctly.
+- Add `validateGeoJson` (geojson-validator): validate a GeoJSON document against RFC 7946's structural rules, geometry type/coordinates shape, polygon ring closure and winding, and a FeatureCollection's required fields.
+
 ## 0.97.0
 - Add `calculatePositionSize` (position-size-risk-calculator): compute a trade's position size from account size, risk percent per trade, entry price, and stop-loss price, plus the risk/reward ratio against an optional target price.
 - Add `detectWeaselWords` (weasel-word-detector): scan text for weasel words, vague hedging phrases that imply evidence or consensus without naming a checkable source, like "studies show" or "many experts believe".

package/README.md

@@ -1,6 +1,6 @@
 # @utilix-tech/sdk
 
-**744 developer utility functions for Node.js: runs locally, no API key required.**
+**750 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)
@@ -67,7 +67,7 @@ const { formatJson } = require("@utilix-tech/sdk/json");
 ```ts
 import { formatJson, minifyJson, diffJson, jsonToTypescript, jsonSchemaToTypescript, validateJson,
          evaluateJsonPath, resolveJsonPointer, applyJsonMergePatch, diffJsonPatch, applyJsonPatch,
-         jsonToCsv, yamlToJson, jsonToYaml, getJsonStats } from "@utilix-tech/sdk/json";
+         jsonToCsv, yamlToJson, jsonToYaml, getJsonStats, validateGeoJson } from "@utilix-tech/sdk/json";
 
 // Format with 2-space indent
 formatJson('{"name":"alice","age":30}', { indent: 2 });
@@ -103,6 +103,10 @@ jsonToCsv('[{"a":1,"b":2}]');
 
 // Validate against JSON Schema
 validateJson(data, schema);
+
+// Validate a GeoJSON document's structure against RFC 7946
+validateGeoJson('{"type":"Point","coordinates":[30,10]}');
+// { valid: true, type: "Point", errors: [], warnings: [] }
 ```
 
 ---
@@ -463,6 +467,10 @@ calculateVideoBitrate({ mode: "size-from-bitrate", durationSeconds: 600, videoBi
 calculateRuleOf72(8, "rate-to-years");
 // { ruleOf72Estimate: 9, exactValue: 9.0065, errorPercent: -0.0718, ... }
 
+// Frame count <-> SMPTE timecode <-> seconds, with correct NTSC drop-frame handling
+convertTimecode({ mode: "frames-to-timecode", frameRate: 29.97, dropFrame: true, frameCount: 17982 });
+// { timecode: "00:10:00;00", frameCount: 17982, seconds: 600 }
+
 // EMI: equated monthly installment with a year-by-year principal/interest breakdown
 calculateEmi(500000, 8.5, 5, "years");
 // { emi: 10258.27, totalInterest: 115495.89, tenureMonths: 60, yearlyBreakdown: [...] }
@@ -802,6 +810,16 @@ calculatePositionSize({ accountSize: 10000, riskPercent: 1, entryPrice: 50, stop
 import { detectWeaselWords } from "@utilix-tech/sdk/text";
 detectWeaselWords("Studies show that many experts believe this works.");
 // { totalWords: 8, totalMatches: 2, density: 25, matches: [{ phrase: "many experts believe", count: 1, indices: [...] }, { phrase: "studies show", count: 1, indices: [...] }] }
+
+// Dividend yield from annual dividend/share price, plus payout + retention ratio if EPS is given
+import { calculateDividendYield } from "@utilix-tech/sdk/units";
+calculateDividendYield({ annualDividendPerShare: 2, sharePrice: 100, epsPerShare: 5 });
+// { dividendYieldPercent: 2, payoutRatioPercent: 40, retentionRatioPercent: 60, ... }
+
+// SSH known_hosts SHA256/MD5 fingerprints (matches `ssh-keygen -lf`), flags weak RSA/ssh-dss keys
+import { checkKnownHostsFingerprints } from "@utilix-tech/sdk/hashing";
+checkKnownHostsFingerprints("example.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIPgoxEP6yy3WPraZXnSJFc9Ly5tby6R7TVyMeAOuYORR");
+// { entries: [{ host: "example.com", keyType: "ssh-ed25519", fingerprintSha256: "SHA256:...", fingerprintMd5: "MD5:...", bits: 256, weak: false }] }
 ```
 
 ---

package/dist/{chunk-PET2CGTH.js → chunk-3BFKPP5R.js}

@@ -11,6 +11,7 @@ __export(hashing_exports, {
   HASH_BITS: () => HASH_BITS,
   ROUND_OPTIONS: () => ROUND_OPTIONS,
   SRI_ALGORITHMS: () => SRI_ALGORITHMS,
+  checkKnownHostsFingerprints: () => checkKnownHostsFingerprints,
   createEntry: () => createEntry,
   generateBcryptHash: () => generateBcryptHash,
   generateEtag: () => generateEtag,
@@ -292,5 +293,93 @@ function generateEtag(content, algorithm = "SHA-1", weak = false) {
   const etag = weak ? `W/${quoted}` : quoted;
   return { algorithm, weak, hash, etag, headerName: "ETag", snippet: `ETag: ${etag}` };
 }
+function _readSshString(buf, offset) {
+  if (offset + 4 > buf.length) return null;
+  const len = buf.readUInt32BE(offset);
+  const start = offset + 4;
+  const end = start + len;
+  if (end > buf.length) return null;
+  return { value: buf.subarray(start, end), next: end };
+}
+function _mpintBitLength(buf) {
+  let i = 0;
+  while (i < buf.length - 1 && buf[i] === 0) i++;
+  const trimmed = buf.subarray(i);
+  if (trimmed.length === 0) return 0;
+  let bits = (trimmed.length - 1) * 8;
+  let firstByte = trimmed[0];
+  while (firstByte > 0) {
+    bits++;
+    firstByte >>= 1;
+  }
+  return bits;
+}
+function _analyzeKnownHostsKey(keyType, blob) {
+  if (keyType === "ssh-dss") {
+    return { weak: true, weakReason: "DSA (ssh-dss) keys are deprecated and considered weak" };
+  }
+  if (keyType === "ssh-rsa") {
+    const typeField = _readSshString(blob, 0);
+    if (!typeField) return { weak: false };
+    const eField = _readSshString(blob, typeField.next);
+    if (!eField) return { weak: false };
+    const nField = _readSshString(blob, eField.next);
+    if (!nField) return { weak: false };
+    const bits = _mpintBitLength(nField.value);
+    return bits > 0 && bits < 2048 ? { bits, weak: true, weakReason: `RSA modulus is only ${bits} bits; 2048+ is recommended` } : { bits, weak: false };
+  }
+  if (keyType === "ssh-ed25519") {
+    return { bits: 256, weak: false };
+  }
+  if (keyType.startsWith("ecdsa-sha2-")) {
+    const curve = keyType.split("-").pop() ?? "";
+    const bits = curve === "nistp256" ? 256 : curve === "nistp384" ? 384 : curve === "nistp521" ? 521 : void 0;
+    return { bits, weak: false };
+  }
+  return { weak: false };
+}
+function checkKnownHostsFingerprints(input) {
+  if (typeof input !== "string" || input.trim().length === 0) {
+    return { error: "input is required" };
+  }
+  const lines = input.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  if (lines.length === 0) {
+    return { error: "No known_hosts entries found" };
+  }
+  const entries = [];
+  for (const line of lines) {
+    const parts = line.split(/\s+/);
+    let idx = 0;
+    if (parts[0] === "@cert-authority" || parts[0] === "@revoked") idx = 1;
+    if (parts.length < idx + 3) {
+      return { error: `Malformed line: "${line}"` };
+    }
+    const host = parts[idx];
+    const keyType = parts[idx + 1];
+    const base64Key = parts[idx + 2];
+    let blob;
+    try {
+      blob = Buffer.from(base64Key, "base64");
+    } catch {
+      return { error: `Invalid base64 key for host "${host}"` };
+    }
+    if (blob.length === 0) {
+      return { error: `Invalid base64 key for host "${host}"` };
+    }
+    const sha256 = createHash("sha256").update(blob).digest("base64").replace(/=+$/, "");
+    const md52 = createHash("md5").update(blob).digest("hex").replace(/(.{2})(?=.)/g, "$1:");
+    const analysis = _analyzeKnownHostsKey(keyType, blob);
+    entries.push({
+      host,
+      keyType,
+      fingerprintSha256: `SHA256:${sha256}`,
+      fingerprintMd5: `MD5:${md52}`,
+      bits: analysis.bits,
+      weak: analysis.weak,
+      weakReason: analysis.weakReason
+    });
+  }
+  return { entries };
+}
 
-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 };
+export { ETAG_ALGORITHMS, HASH_ALGORITHMS, HASH_BITS, ROUND_OPTIONS, SRI_ALGORITHMS, checkKnownHostsFingerprints, createEntry, generateBcryptHash, generateEtag, generateHtpasswdFile, generateMd5Hash, generatePlain, generateSha1Hash, generateSri, generateSriAll, hashAll, hashOne, hashPassword, hashWithTiming, hashing_exports, parseHtpasswdFile, validateRounds, validateUsername, verifyPassword };

package/dist/{chunk-NFTUG3XP.js → chunk-3LHLFKP7.js}

@@ -34,6 +34,7 @@ __export(units_exports, {
   calculateDebtToIncomeRatio: () => calculateDebtToIncomeRatio,
   calculateDepreciationSchedule: () => calculateDepreciationSchedule,
   calculateDiscount: () => calculateDiscount,
+  calculateDividendYield: () => calculateDividendYield,
   calculateEmi: () => calculateEmi,
   calculateExtraPaymentPayoff: () => calculateExtraPaymentPayoff,
   calculateFreelancerRate: () => calculateFreelancerRate,
@@ -66,6 +67,7 @@ __export(units_exports, {
   convertAprApy: () => convertAprApy,
   convertBytes: () => convertBytes,
   convertIp: () => convertIp,
+  convertTimecode: () => convertTimecode,
   coverBox: () => coverBox,
   decimalToIp: () => decimalToIp,
   decimalToIpCidr: () => decimalToIpCidr,
@@ -3304,5 +3306,143 @@ function calculatePositionSize(input) {
     targetOnCorrectSide
   };
 }
+var TIMECODE_NOMINAL_FPS = {
+  "23.976": 24,
+  "24": 24,
+  "25": 25,
+  "29.97": 30,
+  "30": 30,
+  "50": 50,
+  "59.94": 60,
+  "60": 60
+};
+function _timecodeNominalFps(frameRate) {
+  return TIMECODE_NOMINAL_FPS[String(frameRate)] ?? null;
+}
+function _timecodeIsDropFrameEligible(frameRate) {
+  return frameRate === 29.97 || frameRate === 59.94;
+}
+function _framesToPlainTimecode(frameNumber, nominalFps) {
+  const framesPerDay = nominalFps * 86400;
+  const fn = (frameNumber % framesPerDay + framesPerDay) % framesPerDay;
+  const frames = fn % nominalFps;
+  const totalSeconds = Math.floor(fn / nominalFps);
+  return {
+    hours: Math.floor(totalSeconds / 3600) % 24,
+    minutes: Math.floor(totalSeconds / 60) % 60,
+    seconds: totalSeconds % 60,
+    frames
+  };
+}
+function _plainTimecodeToFrames(hh, mm, ss, ff, nominalFps) {
+  return nominalFps * 3600 * hh + nominalFps * 60 * mm + nominalFps * ss + ff;
+}
+function _framesToDropFrameTimecode(frameNumber, nominalFps, frameRate) {
+  const dropFrames = nominalFps === 30 ? 2 : 4;
+  const framesPer24Hours = Math.round(frameRate * 86400);
+  const framesPer10Minutes = Math.round(frameRate * 600);
+  const framesPerMinute = nominalFps * 60 - dropFrames;
+  const fn = (frameNumber % framesPer24Hours + framesPer24Hours) % framesPer24Hours;
+  const d = Math.floor(fn / framesPer10Minutes);
+  const m = fn % framesPer10Minutes;
+  let frameNumberOut = fn + 9 * dropFrames * d;
+  if (m > dropFrames) {
+    frameNumberOut += dropFrames * Math.floor((m - dropFrames) / framesPerMinute);
+  }
+  const frames = frameNumberOut % nominalFps;
+  const totalSeconds = Math.floor(frameNumberOut / nominalFps);
+  return {
+    hours: Math.floor(totalSeconds / 3600) % 24,
+    minutes: Math.floor(totalSeconds / 60) % 60,
+    seconds: totalSeconds % 60,
+    frames
+  };
+}
+function _dropFrameTimecodeToFrames(hh, mm, ss, ff, nominalFps) {
+  const dropFrames = nominalFps === 30 ? 2 : 4;
+  const totalMinutes = 60 * hh + mm;
+  return nominalFps * 3600 * hh + nominalFps * 60 * mm + nominalFps * ss + ff - dropFrames * (totalMinutes - Math.floor(totalMinutes / 10));
+}
+function _formatTimecode(parts, dropFrame) {
+  const p2 = (n) => String(n).padStart(2, "0");
+  const sep = dropFrame ? ";" : ":";
+  return `${p2(parts.hours)}:${p2(parts.minutes)}:${p2(parts.seconds)}${sep}${p2(parts.frames)}`;
+}
+function convertTimecode(input) {
+  const { mode, frameRate } = input;
+  const dropFrame = input.dropFrame ?? false;
+  const nominalFps = _timecodeNominalFps(frameRate);
+  if (nominalFps === null) {
+    return { error: "frameRate must be one of 23.976, 24, 25, 29.97, 30, 50, 59.94, 60" };
+  }
+  if (dropFrame && !_timecodeIsDropFrameEligible(frameRate)) {
+    return { error: "dropFrame is only valid for frameRate 29.97 or 59.94" };
+  }
+  if (mode === "frames-to-timecode") {
+    const { frameCount } = input;
+    if (typeof frameCount !== "number" || !Number.isFinite(frameCount) || frameCount < 0 || Math.floor(frameCount) !== frameCount) {
+      return { error: 'frameCount must be a non-negative integer for mode "frames-to-timecode"' };
+    }
+    const parts = dropFrame ? _framesToDropFrameTimecode(frameCount, nominalFps, frameRate) : _framesToPlainTimecode(frameCount, nominalFps);
+    return {
+      mode,
+      frameRate,
+      dropFrame,
+      frameCount,
+      timecode: _formatTimecode(parts, dropFrame),
+      seconds: Math.round(frameCount / frameRate * 1e6) / 1e6
+    };
+  }
+  if (mode === "timecode-to-frames") {
+    const { timecode } = input;
+    if (typeof timecode !== "string") return { error: 'timecode must be a string for mode "timecode-to-frames"' };
+    const match = /^(\d{2}):(\d{2}):(\d{2})[:;](\d{2})$/.exec(timecode.trim());
+    if (!match) return { error: "timecode must be in the form HH:MM:SS:FF (or HH:MM:SS;FF)" };
+    const [, hhS, mmS, ssS, ffS] = match;
+    const hh = Number(hhS), mm = Number(mmS), ss = Number(ssS), ff = Number(ffS);
+    if (hh > 23) return { error: "hours must be 00-23" };
+    if (mm > 59) return { error: "minutes must be 00-59" };
+    if (ss > 59) return { error: "seconds must be 00-59" };
+    if (ff >= nominalFps) return { error: `frames must be 00-${nominalFps - 1} at this frame rate` };
+    if (dropFrame && ff <= 1 && ss === 0 && mm % 10 !== 0) {
+      return { error: `frame ${ffS} at ${hhS}:${mmS}:${ssS} does not exist in drop-frame timecode: frames 00 and 01 are dropped at the start of every minute except every 10th minute` };
+    }
+    const frameCount = dropFrame ? _dropFrameTimecodeToFrames(hh, mm, ss, ff, nominalFps) : _plainTimecodeToFrames(hh, mm, ss, ff, nominalFps);
+    return {
+      mode,
+      frameRate,
+      dropFrame,
+      frameCount,
+      timecode: _formatTimecode({ hours: hh, minutes: mm, seconds: ss, frames: ff }, dropFrame),
+      seconds: Math.round(frameCount / frameRate * 1e6) / 1e6
+    };
+  }
+  return { error: 'mode must be "frames-to-timecode" or "timecode-to-frames"' };
+}
+function calculateDividendYield(input) {
+  const { annualDividendPerShare, sharePrice, epsPerShare } = input;
+  if (!Number.isFinite(annualDividendPerShare) || annualDividendPerShare < 0) {
+    return { error: "annualDividendPerShare must be a finite number greater than or equal to zero" };
+  }
+  if (!Number.isFinite(sharePrice) || sharePrice <= 0) {
+    return { error: "sharePrice must be a finite number greater than zero" };
+  }
+  const round4 = (n) => Math.round(n * 1e4) / 1e4;
+  const result = {
+    annualDividendPerShare: round4(annualDividendPerShare),
+    sharePrice: round4(sharePrice),
+    dividendYieldPercent: round4(annualDividendPerShare / sharePrice * 100)
+  };
+  if (epsPerShare !== void 0) {
+    if (!Number.isFinite(epsPerShare) || epsPerShare <= 0) {
+      return { error: "epsPerShare must be a finite number greater than zero when provided" };
+    }
+    const payoutRatioPercent = annualDividendPerShare / epsPerShare * 100;
+    result.epsPerShare = round4(epsPerShare);
+    result.payoutRatioPercent = round4(payoutRatioPercent);
+    result.retentionRatioPercent = round4(100 - payoutRatioPercent);
+  }
+  return result;
+}
 
-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, GPA_GRADE_POINTS, USD_DENOMINATIONS, applySuccessiveDiscounts, autoFormat, bumpVersion, calcAspectRatio, calcSubnet, calculateAnnuityPayout, calculateBlendedLoanRate, calculateBreakEven, calculateCashBreakdown, calculateCashRounding, calculateCdMaturity, calculateChange, calculateCompoundInterest, calculateCreditCardMinimumPayment, calculateCreditUtilization, calculateDebtToIncomeRatio, calculateDepreciationSchedule, calculateDiscount, calculateEmi, calculateExtraPaymentPayoff, calculateFreelancerRate, calculateGpa, calculateLoan, calculateLoanPrepaymentPenalty, calculateLoanRefinance, calculateMarginMarkup, calculateMortgagePoints, calculateMovingAverages, calculatePaybackPeriod, calculatePercentageChange, calculatePositionSize, calculateRealRateOfReturn, calculateRequiredBandwidth, calculateRoi, calculateRuleOf72, calculateSalesCommission, calculateSavingsGoal, calculateSimpleInterest, calculateTax, calculateTaxEquivalentYield, calculateTimeValue, calculateTipSplit, calculateTransferTime, calculateVideoBitrate, compareSemver, compareUnitPrices, convert, convertAprApy, convertBytes, convertIp, coverBox, decimalToIp, decimalToIpCidr, describePermissions, detectNegativeAmortization, estimateAudioFileSize, fitIntoBox, formatNumber, formatValue, formatVwValue, formatWithSeparator, gcd, intersectSemverRanges, ipFromBinary, ipFromDecimal, ipFromHex, ipToBinary, ipToDecimal, ipToDecimalCidr, ipToHex, ipToOctal, isValid, isValidCidr, isValidIp, isValidIpv4, marginToMarkup, markupToMargin, octalToPermissions, parseFileSize, parseInput, parseNumberString, parseSemver, permissionsToChmod, permissionsToOctal, permissionsToSymbolic, planDebtPayoff, ptToPx, pxToAll, pxToViewport, remToPx, satisfiesRange, scaleByHeight, scaleByWidth, sortVersions, splitSubnet, symbolicToPermissions, units_exports, validateBarcode, validateCardNumber, validateIban, validateIsbn, validateIsin, validateRoutingNumber, validateVin, 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, GPA_GRADE_POINTS, USD_DENOMINATIONS, applySuccessiveDiscounts, autoFormat, bumpVersion, calcAspectRatio, calcSubnet, calculateAnnuityPayout, calculateBlendedLoanRate, calculateBreakEven, calculateCashBreakdown, calculateCashRounding, calculateCdMaturity, calculateChange, calculateCompoundInterest, calculateCreditCardMinimumPayment, calculateCreditUtilization, calculateDebtToIncomeRatio, calculateDepreciationSchedule, calculateDiscount, calculateDividendYield, calculateEmi, calculateExtraPaymentPayoff, calculateFreelancerRate, calculateGpa, calculateLoan, calculateLoanPrepaymentPenalty, calculateLoanRefinance, calculateMarginMarkup, calculateMortgagePoints, calculateMovingAverages, calculatePaybackPeriod, calculatePercentageChange, calculatePositionSize, calculateRealRateOfReturn, calculateRequiredBandwidth, calculateRoi, calculateRuleOf72, calculateSalesCommission, calculateSavingsGoal, calculateSimpleInterest, calculateTax, calculateTaxEquivalentYield, calculateTimeValue, calculateTipSplit, calculateTransferTime, calculateVideoBitrate, compareSemver, compareUnitPrices, convert, convertAprApy, convertBytes, convertIp, convertTimecode, coverBox, decimalToIp, decimalToIpCidr, describePermissions, detectNegativeAmortization, estimateAudioFileSize, fitIntoBox, formatNumber, formatValue, formatVwValue, formatWithSeparator, gcd, intersectSemverRanges, ipFromBinary, ipFromDecimal, ipFromHex, ipToBinary, ipToDecimal, ipToDecimalCidr, ipToHex, ipToOctal, isValid, isValidCidr, isValidIp, isValidIpv4, marginToMarkup, markupToMargin, octalToPermissions, parseFileSize, parseInput, parseNumberString, parseSemver, permissionsToChmod, permissionsToOctal, permissionsToSymbolic, planDebtPayoff, ptToPx, pxToAll, pxToViewport, remToPx, satisfiesRange, scaleByHeight, scaleByWidth, sortVersions, splitSubnet, symbolicToPermissions, units_exports, validateBarcode, validateCardNumber, validateIban, validateIsbn, validateIsin, validateRoutingNumber, validateVin, viewportToPx };

package/dist/{chunk-WUOZHCIC.js → chunk-PAMHORKV.js}

@@ -33,6 +33,7 @@ __export(json_exports, {
   resolveJsonPointer: () => resolveJsonPointer,
   toPascalCase: () => toPascalCase,
   toSnakeCase: () => toSnakeCase,
+  validateGeoJson: () => validateGeoJson,
   validateJson: () => validateJson,
   validateJsonPath: () => validateJsonPath,
   validateJsonString: () => validateJsonString,
@@ -1651,5 +1652,170 @@ function generateJsonPatch(aJson, bJson) {
   }
   return { patch: diffJsonPatch(a, b) };
 }
+var GEOJSON_GEOMETRY_TYPES = /* @__PURE__ */ new Set([
+  "Point",
+  "MultiPoint",
+  "LineString",
+  "MultiLineString",
+  "Polygon",
+  "MultiPolygon",
+  "GeometryCollection"
+]);
+function _isGeoJsonNumber(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function _isGeoJsonPosition(v) {
+  return Array.isArray(v) && (v.length === 2 || v.length === 3) && v.every(_isGeoJsonNumber);
+}
+function _geoJsonPositionsEqual(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function _geoJsonRingSignedArea(ring) {
+  let sum = 0;
+  for (let i = 0; i < ring.length - 1; i++) {
+    const [x1, y1] = ring[i];
+    const [x2, y2] = ring[i + 1];
+    sum += x1 * y2 - x2 * y1;
+  }
+  return sum / 2;
+}
+function _validateGeoJsonPolygonCoords(coords, path, errors, warnings) {
+  if (!Array.isArray(coords) || coords.length === 0) {
+    errors.push({ path, message: "Polygon coordinates must be a non-empty array of linear rings" });
+    return;
+  }
+  coords.forEach((ring, i) => {
+    const ringPath = `${path}[${i}]`;
+    if (!Array.isArray(ring) || ring.length < 4 || !ring.every(_isGeoJsonPosition)) {
+      errors.push({ path: ringPath, message: "each linear ring must have at least 4 positions" });
+      return;
+    }
+    const first = ring[0];
+    const last = ring[ring.length - 1];
+    if (!_geoJsonPositionsEqual(first, last)) {
+      errors.push({ path: ringPath, message: "the first and last positions of a linear ring must be identical (the ring must be closed)" });
+      return;
+    }
+    const area = _geoJsonRingSignedArea(ring);
+    const isExterior = i === 0;
+    if (isExterior && area < 0) {
+      warnings.push({ path: ringPath, message: "exterior ring winds clockwise; RFC 7946 recommends counterclockwise for exterior rings (right-hand rule)" });
+    } else if (!isExterior && area > 0) {
+      warnings.push({ path: ringPath, message: "interior ring (hole) winds counterclockwise; RFC 7946 recommends clockwise for interior rings (right-hand rule)" });
+    }
+  });
+}
+function _validateGeoJsonGeometry(geom, path, errors, warnings) {
+  if (geom === null) return;
+  if (typeof geom !== "object" || Array.isArray(geom)) {
+    errors.push({ path, message: "geometry must be an object or null" });
+    return;
+  }
+  const type = geom.type;
+  if (typeof type !== "string" || !GEOJSON_GEOMETRY_TYPES.has(type)) {
+    errors.push({ path: `${path}.type`, message: `geometry type must be one of ${[...GEOJSON_GEOMETRY_TYPES].join(", ")}` });
+    return;
+  }
+  if (type === "GeometryCollection") {
+    if (!Array.isArray(geom.geometries)) {
+      errors.push({ path: `${path}.geometries`, message: 'GeometryCollection must have a "geometries" array' });
+      return;
+    }
+    geom.geometries.forEach((g, i) => _validateGeoJsonGeometry(g, `${path}.geometries[${i}]`, errors, warnings));
+    return;
+  }
+  const coords = geom.coordinates;
+  const coordPath = `${path}.coordinates`;
+  switch (type) {
+    case "Point":
+      if (!_isGeoJsonPosition(coords)) errors.push({ path: coordPath, message: "Point coordinates must be an array of 2 or 3 numbers" });
+      break;
+    case "MultiPoint":
+      if (!Array.isArray(coords) || !coords.every(_isGeoJsonPosition)) {
+        errors.push({ path: coordPath, message: "MultiPoint coordinates must be an array of positions" });
+      }
+      break;
+    case "LineString":
+      if (!Array.isArray(coords) || coords.length < 2 || !coords.every(_isGeoJsonPosition)) {
+        errors.push({ path: coordPath, message: "LineString coordinates must be an array of at least 2 positions" });
+      }
+      break;
+    case "MultiLineString":
+      if (!Array.isArray(coords) || !coords.every((line) => Array.isArray(line) && line.length >= 2 && line.every(_isGeoJsonPosition))) {
+        errors.push({ path: coordPath, message: "MultiLineString coordinates must be an array of LineString coordinate arrays" });
+      }
+      break;
+    case "Polygon":
+      _validateGeoJsonPolygonCoords(coords, coordPath, errors, warnings);
+      break;
+    case "MultiPolygon":
+      if (!Array.isArray(coords)) {
+        errors.push({ path: coordPath, message: "MultiPolygon coordinates must be an array of Polygon coordinate arrays" });
+      } else {
+        coords.forEach((poly, i) => _validateGeoJsonPolygonCoords(poly, `${coordPath}[${i}]`, errors, warnings));
+      }
+      break;
+  }
+}
+function _validateGeoJsonBbox(bbox, path, errors) {
+  if (bbox === void 0) return;
+  if (!Array.isArray(bbox) || bbox.length % 2 !== 0 || bbox.length < 4 || !bbox.every(_isGeoJsonNumber)) {
+    errors.push({ path: `${path}.bbox`, message: "bbox must be an array of 2*n numbers (min/max per axis)" });
+  }
+}
+function _validateGeoJsonFeature(feature, path, errors, warnings) {
+  if (typeof feature !== "object" || feature === null || Array.isArray(feature)) {
+    errors.push({ path, message: "Feature must be an object" });
+    return;
+  }
+  if (feature.type !== "Feature") {
+    errors.push({ path: `${path}.type`, message: '"type" must be "Feature"' });
+  }
+  if (!("properties" in feature) || typeof feature.properties !== "object") {
+    errors.push({ path: `${path}.properties`, message: '"properties" member is required and must be an object or null' });
+  }
+  if (!("geometry" in feature)) {
+    errors.push({ path: `${path}.geometry`, message: '"geometry" member is required (an object or null)' });
+  } else {
+    _validateGeoJsonGeometry(feature.geometry, `${path}.geometry`, errors, warnings);
+  }
+  _validateGeoJsonBbox(feature.bbox, path, errors);
+}
+function validateGeoJson(input) {
+  let doc;
+  if (typeof input === "string") {
+    try {
+      doc = JSON.parse(input);
+    } catch (e) {
+      return { valid: false, type: null, errors: [{ path: "$", message: `invalid JSON: ${e.message}` }], warnings: [] };
+    }
+  } else {
+    doc = input;
+  }
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) {
+    return { valid: false, type: null, errors: [{ path: "$", message: "document must be a JSON object" }], warnings: [] };
+  }
+  const type = doc.type;
+  if (typeof type !== "string") {
+    return { valid: false, type: null, errors: [{ path: "$.type", message: '"type" member is required' }], warnings: [] };
+  }
+  const errors = [];
+  const warnings = [];
+  _validateGeoJsonBbox(doc.bbox, "$", errors);
+  if (type === "FeatureCollection") {
+    if (!Array.isArray(doc.features)) {
+      errors.push({ path: "$.features", message: 'FeatureCollection must have a "features" array' });
+    } else {
+      doc.features.forEach((feature, i) => _validateGeoJsonFeature(feature, `$.features[${i}]`, errors, warnings));
+    }
+  } else if (type === "Feature") {
+    _validateGeoJsonFeature(doc, "$", errors, warnings);
+  } else if (GEOJSON_GEOMETRY_TYPES.has(type)) {
+    _validateGeoJsonGeometry(doc, "$", errors, warnings);
+  } else {
+    errors.push({ path: "$.type", message: '"type" must be one of Feature, FeatureCollection, or a geometry type' });
+  }
+  return { valid: errors.length === 0, type, errors, warnings };
+}
 
-export { applyJsonMergePatch, applyJsonPatch, csvToJson, detectFormat, diffJson, diffJsonPatch, evaluateJsonPath, formatDiffLine, formatJson, generateExample, generateJsonPatch, getJsonStats, inferGoType, inferPythonType, inferType, jsonSchemaToTypescript, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, json_exports, mergeJsonPatch, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateJson, validateJsonPath, validateJsonString, yamlToJson };
+export { applyJsonMergePatch, applyJsonPatch, csvToJson, detectFormat, diffJson, diffJsonPatch, evaluateJsonPath, formatDiffLine, formatJson, generateExample, generateJsonPatch, getJsonStats, inferGoType, inferPythonType, inferType, jsonSchemaToTypescript, jsonToCsv, jsonToGo, jsonToPython, jsonToTypescript, jsonToYaml, jsonToZod, json_exports, mergeJsonPatch, minifyJson, parseJson, parseStructs, resolveJsonPointer, toPascalCase, toSnakeCase, validateGeoJson, validateJson, validateJsonPath, validateJsonString, yamlToJson };

package/dist/{hashing-CJjlvqS_.d.ts → hashing-D2VIYoFn.d.cts}

@@ -9,6 +9,7 @@
  *                       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)
+ *   - ssh-known-hosts-fingerprint-checker: checkKnownHostsFingerprints
  */
 type HashAlgorithm = 'MD5' | 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
 declare const HASH_ALGORITHMS: HashAlgorithm[];
@@ -88,6 +89,32 @@ interface EtagResult {
 declare function generateEtag(content: string, algorithm?: EtagAlgorithm, weak?: boolean): EtagResult | {
     error: string;
 };
+interface KnownHostsEntry {
+    host: string;
+    keyType: string;
+    fingerprintSha256: string;
+    fingerprintMd5: string;
+    bits?: number;
+    weak: boolean;
+    weakReason?: string;
+}
+interface KnownHostsCheckResult {
+    entries: KnownHostsEntry[];
+}
+/**
+ * Parse an ssh_known_hosts file (or a single `host keytype base64key
+ * [comment]` line) and compute each entry's SHA256 and MD5 fingerprint the
+ * same way `ssh-keygen -lf` does: SHA256 is the base64 (no padding) of the
+ * SHA-256 digest of the decoded key blob, MD5 is the colon-separated hex of
+ * the MD5 digest. Also decodes the key type and, for RSA, the modulus bit
+ * length, flagging a weak RSA key (<2048 bits) or a deprecated ssh-dss
+ * (DSA) key. `@cert-authority`/`@revoked` markers are skipped. Operates
+ * only on public key material already present in the file; never touches a
+ * private key.
+ */
+declare function checkKnownHostsFingerprints(input: string): KnownHostsCheckResult | {
+    error: string;
+};
 
 type hashing_BcryptResult = BcryptResult;
 declare const hashing_ETAG_ALGORITHMS: typeof ETAG_ALGORITHMS;
@@ -99,10 +126,13 @@ type hashing_HashAlgorithm = HashAlgorithm;
 type hashing_HashResult = HashResult;
 type hashing_HtpasswdAlgorithm = HtpasswdAlgorithm;
 type hashing_HtpasswdEntry = HtpasswdEntry;
+type hashing_KnownHostsCheckResult = KnownHostsCheckResult;
+type hashing_KnownHostsEntry = KnownHostsEntry;
 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_checkKnownHostsFingerprints: typeof checkKnownHostsFingerprints;
 declare const hashing_createEntry: typeof createEntry;
 declare const hashing_generateBcryptHash: typeof generateBcryptHash;
 declare const hashing_generateEtag: typeof generateEtag;
@@ -121,7 +151,7 @@ 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 { 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, type hashing_KnownHostsCheckResult as KnownHostsCheckResult, type hashing_KnownHostsEntry as KnownHostsEntry, hashing_ROUND_OPTIONS as ROUND_OPTIONS, hashing_SRI_ALGORITHMS as SRI_ALGORITHMS, type hashing_SriAlgorithm as SriAlgorithm, type hashing_SriResult as SriResult, hashing_checkKnownHostsFingerprints as checkKnownHostsFingerprints, 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 };
+export { validateRounds as A, type BcryptResult as B, validateUsername as C, verifyPassword as D, ETAG_ALGORITHMS as E, HASH_ALGORITHMS as H, type KnownHostsCheckResult as K, 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 KnownHostsEntry as i, type SriAlgorithm as j, type SriResult as k, checkKnownHostsFingerprints as l, createEntry as m, generateBcryptHash as n, generateEtag as o, generateHtpasswdFile as p, generateMd5Hash as q, generatePlain as r, generateSha1Hash as s, generateSri as t, generateSriAll as u, hashAll as v, hashOne as w, hashPassword as x, hashWithTiming as y, parseHtpasswdFile as z };