@utilix-tech/sdk 0.97.0 → 0.99.0

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

@@ -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 };

package/dist/index.cjs

@@ -71,6 +71,7 @@ __export(json_exports, {
   resolveJsonPointer: () => resolveJsonPointer,
   toPascalCase: () => toPascalCase,
   toSnakeCase: () => toSnakeCase,
+  validateGeoJson: () => validateGeoJson,
   validateJson: () => validateJson,
   validateJsonPath: () => validateJsonPath,
   validateJsonString: () => validateJsonString,
@@ -1689,6 +1690,171 @@ 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 };
+}
 
 // src/tools/encoding.ts
 var encoding_exports = {};
@@ -2020,6 +2186,7 @@ __export(hashing_exports, {
   HASH_BITS: () => HASH_BITS,
   ROUND_OPTIONS: () => ROUND_OPTIONS,
   SRI_ALGORITHMS: () => SRI_ALGORITHMS,
+  checkKnownHostsFingerprints: () => checkKnownHostsFingerprints,
   createEntry: () => createEntry,
   generateBcryptHash: () => generateBcryptHash,
   generateEtag: () => generateEtag,
@@ -2301,6 +2468,94 @@ 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 = crypto.createHash("sha256").update(blob).digest("base64").replace(/=+$/, "");
+    const md52 = crypto.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 };
+}
 
 // src/tools/text.ts
 var text_exports = {};
@@ -9478,6 +9733,7 @@ __export(units_exports, {
   calculateDebtToIncomeRatio: () => calculateDebtToIncomeRatio,
   calculateDepreciationSchedule: () => calculateDepreciationSchedule,
   calculateDiscount: () => calculateDiscount,
+  calculateDividendYield: () => calculateDividendYield,
   calculateEmi: () => calculateEmi,
   calculateExtraPaymentPayoff: () => calculateExtraPaymentPayoff,
   calculateFreelancerRate: () => calculateFreelancerRate,
@@ -9510,6 +9766,7 @@ __export(units_exports, {
   convertAprApy: () => convertAprApy,
   convertBytes: () => convertBytes,
   convertIp: () => convertIp,
+  convertTimecode: () => convertTimecode,
   coverBox: () => coverBox,
   decimalToIp: () => decimalToIp,
   decimalToIpCidr: () => decimalToIpCidr,
@@ -12748,6 +13005,144 @@ 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;
+}
 
 // src/tools/network.ts
 var network_exports = {};

package/dist/index.d.cts

@@ -1,11 +1,11 @@
-export { j as json } from './json-Ca6gZCNB.cjs';
+export { j as json } from './json-BtRszk1w.cjs';
 export { e as encoding } from './encoding-Dk3wpmb3.cjs';
-export { h as hashing } from './hashing-CJjlvqS_.cjs';
+export { h as hashing } from './hashing-D2VIYoFn.cjs';
 export { t as text } from './text-DFCNpyvH.cjs';
 export { d as data } from './data-Dg5dEwWl.cjs';
 export { g as generators } from './generators-DAXXrMvG.cjs';
 export { t as time } from './time-VMAy_SrV.cjs';
-export { u as units } from './units-7rkeDBbW.cjs';
+export { u as units } from './units-CmkM7-WZ.cjs';
 export { n as network } from './network-B6fQrsCc.cjs';
 export { a as api } from './api-CQnIUrVB.cjs';
 export { c as code } from './code-CZHElFHu.cjs';

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-export { j as json } from './json-Ca6gZCNB.js';
+export { j as json } from './json-BtRszk1w.js';
 export { e as encoding } from './encoding-Dk3wpmb3.js';
-export { h as hashing } from './hashing-CJjlvqS_.js';
+export { h as hashing } from './hashing-D2VIYoFn.js';
 export { t as text } from './text-DFCNpyvH.js';
 export { d as data } from './data-Dg5dEwWl.js';
 export { g as generators } from './generators-DAXXrMvG.js';
 export { t as time } from './time-VMAy_SrV.js';
-export { u as units } from './units-7rkeDBbW.js';
+export { u as units } from './units-CmkM7-WZ.js';
 export { n as network } from './network-B6fQrsCc.js';
 export { a as api } from './api-CQnIUrVB.js';
 export { c as code } from './code-CZHElFHu.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { media_exports as media } from './chunk-YSS4VVZU.js';
-export { units_exports as units } from './chunk-NFTUG3XP.js';
+export { units_exports as units } from './chunk-3LHLFKP7.js';
 export { network_exports as network } from './chunk-K242OOF4.js';
 export { api_exports as api } from './chunk-U2HREMZU.js';
 export { code_exports as code } from './chunk-KRPIOHJ4.js';
@@ -7,9 +7,9 @@ export { color_exports as color } from './chunk-BPVAB4P2.js';
 export { css_exports as css } from './chunk-6YPV2AB5.js';
 export { misc_exports as misc } from './chunk-GX7H6TAX.js';
 export { ai_agent_exports as ai_agent } from './chunk-5VVC7BHS.js';
-export { json_exports as json } from './chunk-WUOZHCIC.js';
+export { json_exports as json } from './chunk-PAMHORKV.js';
 export { encoding_exports as encoding } from './chunk-DOWQZUTP.js';
-export { hashing_exports as hashing } from './chunk-PET2CGTH.js';
+export { hashing_exports as hashing } from './chunk-3BFKPP5R.js';
 export { text_exports as text } from './chunk-2YWKRNDM.js';
 export { data_exports as data } from './chunk-NTHUTIZH.js';
 export { generators_exports as generators } from './chunk-422ICOZX.js';

package/dist/{json-Ca6gZCNB.d.cts → json-BtRszk1w.d.cts}

@@ -16,6 +16,7 @@
  *   - json-schema-to-typescript : jsonSchemaToTypescript
  *   - json-merge-patch : mergeJsonPatch, applyJsonMergePatch
  *   - json-patch       : diffJsonPatch, applyJsonPatch, generateJsonPatch
+ *   - geojson-validator : validateGeoJson
  */
 type ParseStatus = 'idle' | 'valid' | 'error';
 interface JsonParseResult {
@@ -258,11 +259,35 @@ declare function generateJsonPatch(aJson: string, bJson: string): {
 } | {
     error: string;
 };
+interface GeoJsonIssue {
+    path: string;
+    message: string;
+}
+interface GeoJsonValidateResult {
+    valid: boolean;
+    type: string | null;
+    errors: GeoJsonIssue[];
+    warnings: GeoJsonIssue[];
+}
+/**
+ * Validate a GeoJSON document's structure against RFC 7946: the correct
+ * geometry type and coordinates shape for each of the seven geometry types,
+ * linear ring closure (first and last position identical) for Polygon and
+ * MultiPolygon, a Feature's required `properties`/`geometry` members, and a
+ * FeatureCollection's required `features` array. Also warns, without
+ * failing validation, when a Polygon ring winds the "wrong" way under RFC
+ * 7946's right-hand rule, since that's a SHOULD, not a MUST, and plenty of
+ * real-world producers don't follow it. Pure structural validation; no map
+ * is rendered and no tile server is ever contacted.
+ */
+declare function validateGeoJson(input: string | object): GeoJsonValidateResult;
 
 type json_ConvertOptions = ConvertOptions;
 type json_CsvOptions = CsvOptions;
 type json_DiffNode = DiffNode;
 type json_DiffType = DiffType;
+type json_GeoJsonIssue = GeoJsonIssue;
+type json_GeoJsonValidateResult = GeoJsonValidateResult;
 type json_GoField = GoField;
 type json_GoStruct = GoStruct;
 type json_JsonDiffResult = JsonDiffResult;
@@ -310,12 +335,13 @@ declare const json_parseStructs: typeof parseStructs;
 declare const json_resolveJsonPointer: typeof resolveJsonPointer;
 declare const json_toPascalCase: typeof toPascalCase;
 declare const json_toSnakeCase: typeof toSnakeCase;
+declare const json_validateGeoJson: typeof validateGeoJson;
 declare const json_validateJson: typeof validateJson;
 declare const json_validateJsonPath: typeof validateJsonPath;
 declare const json_validateJsonString: typeof validateJsonString;
 declare const json_yamlToJson: typeof yamlToJson;
 declare namespace json {
-  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPatchOp as JsonPatchOp, type json_JsonPatchOperation as JsonPatchOperation, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_JsonSchemaLike as JsonSchemaLike, type json_JsonSchemaToTsOptions as JsonSchemaToTsOptions, type json_MergePatchResult as MergePatchResult, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_applyJsonMergePatch as applyJsonMergePatch, json_applyJsonPatch as applyJsonPatch, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_diffJsonPatch as diffJsonPatch, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_generateJsonPatch as generateJsonPatch, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonSchemaToTypescript as jsonSchemaToTypescript, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_mergeJsonPatch as mergeJsonPatch, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
+  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GeoJsonIssue as GeoJsonIssue, type json_GeoJsonValidateResult as GeoJsonValidateResult, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPatchOp as JsonPatchOp, type json_JsonPatchOperation as JsonPatchOperation, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_JsonSchemaLike as JsonSchemaLike, type json_JsonSchemaToTsOptions as JsonSchemaToTsOptions, type json_MergePatchResult as MergePatchResult, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_applyJsonMergePatch as applyJsonMergePatch, json_applyJsonPatch as applyJsonPatch, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_diffJsonPatch as diffJsonPatch, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_generateJsonPatch as generateJsonPatch, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonSchemaToTypescript as jsonSchemaToTypescript, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_mergeJsonPatch as mergeJsonPatch, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateGeoJson as validateGeoJson, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
 }
 
-export { validateJsonPath as $, getJsonStats as A, inferGoType as B, type ConvertOptions as C, type DiffNode as D, inferPythonType as E, inferType as F, type GoField as G, jsonSchemaToTypescript as H, jsonToCsv as I, type JsonDiffResult as J, jsonToGo as K, jsonToPython as L, type MergePatchResult as M, jsonToTypescript as N, jsonToYaml as O, type ParseStatus as P, jsonToZod as Q, mergeJsonPatch as R, minifyJson as S, parseJson as T, parseStructs as U, type ValidationError as V, resolveJsonPointer as W, toPascalCase as X, toSnakeCase as Y, type ZodOptions as Z, validateJson as _, type CsvOptions as a, validateJsonString as a0, yamlToJson as a1, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPatchOp as e, type JsonPatchOperation as f, type JsonPathResult as g, type JsonPointerResult as h, type JsonSchemaLike as i, json as j, type JsonSchemaToTsOptions as k, type PythonClass as l, type PythonField as m, type PythonMode as n, type ValidationResult as o, applyJsonMergePatch as p, applyJsonPatch as q, csvToJson as r, detectFormat as s, diffJson as t, diffJsonPatch as u, evaluateJsonPath as v, formatDiffLine as w, formatJson as x, generateExample as y, generateJsonPatch as z };
+export { toSnakeCase as $, generateExample as A, generateJsonPatch as B, type ConvertOptions as C, type DiffNode as D, getJsonStats as E, inferGoType as F, type GeoJsonIssue as G, inferPythonType as H, inferType as I, type JsonDiffResult as J, jsonSchemaToTypescript as K, jsonToCsv as L, type MergePatchResult as M, jsonToGo as N, jsonToPython as O, type ParseStatus as P, jsonToTypescript as Q, jsonToYaml as R, jsonToZod as S, mergeJsonPatch as T, minifyJson as U, type ValidationError as V, parseJson as W, parseStructs as X, resolveJsonPointer as Y, type ZodOptions as Z, toPascalCase as _, type CsvOptions as a, validateGeoJson as a0, validateJson as a1, validateJsonPath as a2, validateJsonString as a3, yamlToJson as a4, type DiffType as b, type GeoJsonValidateResult as c, type GoField as d, type GoStruct as e, type JsonParseResult as f, type JsonPatchOp as g, type JsonPatchOperation as h, type JsonPathResult as i, json as j, type JsonPointerResult as k, type JsonSchemaLike as l, type JsonSchemaToTsOptions as m, type PythonClass as n, type PythonField as o, type PythonMode as p, type ValidationResult as q, applyJsonMergePatch as r, applyJsonPatch as s, csvToJson as t, detectFormat as u, diffJson as v, diffJsonPatch as w, evaluateJsonPath as x, formatDiffLine as y, formatJson as z };