@claritylabs/cl-sdk 3.0.31 → 3.0.33

package/dist/index.js

@@ -3313,6 +3313,15 @@ function moneyValue(value) {
   if (/^\d{1,3}(?:,\d{3})*(?:\.\d{2})?$/.test(clean)) return `$${clean}`;
   return clean;
 }
+function premiumValue(value) {
+  const clean = cleanValue(value);
+  if (!clean) return void 0;
+  if (/\$[A-Z0-9]/i.test(clean)) return clean;
+  if (/\b(?:CAD|USD)\b/i.test(clean) && /(?:\d|X{2,})/i.test(clean)) return clean;
+  if (/^\d{1,3}(?:,\d{3})+\.\d{2}$/.test(clean) || /^\d+\.\d{2}$/.test(clean)) return `$${clean}`;
+  if (/^X{2,}(?:,X{3})*(?:\.X{2})$/i.test(clean)) return clean;
+  return void 0;
+}
 function nodeText(node) {
   return normalizeWhitespace3([
     node.title,
@@ -3328,6 +3337,14 @@ function valueFromNode(node, value, confidence = "medium") {
     sourceSpanIds: node.sourceSpanIds
   };
 }
+function valueFromNodes(nodes, value, confidence = "medium", normalizedValue) {
+  return {
+    value,
+    ...normalizedValue ? { normalizedValue } : {},
+    confidence,
+    ...sourceIds(nodes)
+  };
+}
 function firstMatch(nodes, patterns) {
   for (const node of nodes) {
     const text = nodeText(node);
@@ -3394,27 +3411,96 @@ function firstCleanMatch(nodes, patterns, clean) {
 function cleanNamedInsured(value) {
   const clean = cleanValue(value.replace(/\bborn\s+on\b.*$/i, "").replace(/\bage\s+nearest\b.*$/i, "").replace(/\bbeneficiary\b.*$/i, ""));
   if (!clean || clean.length > 160) return void 0;
+  if (!/[A-Za-z0-9]/.test(clean)) return void 0;
   if (/^(person|persons)\b/i.test(clean)) return void 0;
+  if (/^(insurance amount|benefit amount|policy number|policy date|owner|beneficiary|premium|coverage|risk classification)\b/i.test(clean)) {
+    return void 0;
+  }
   if (/\b(table of contents|policy wording|provided solely|convenience|not to be construed|actual policy issued)\b/i.test(clean)) {
     return void 0;
   }
   return clean;
 }
+var PARTY_LABEL_PATTERNS = {
+  namedInsured: /^(?:item\s*\d+[.)]?\s*)?(?:named insured(?:\s+and\s+address)?|insured name)$/i,
+  insurer: /^(?:carrier|insurer|security)$/i,
+  broker: /^(?:broker(?:\s+of\s+record)?|producer|agent)$/i
+};
+function partyLabelKind(value) {
+  const clean = cleanValue(value.replace(/^\s*column\s+\d+\s*:\s*/i, ""));
+  if (!clean) return void 0;
+  if (PARTY_LABEL_PATTERNS.namedInsured.test(clean)) return "namedInsured";
+  if (PARTY_LABEL_PATTERNS.insurer.test(clean)) return "insurer";
+  if (PARTY_LABEL_PATTERNS.broker.test(clean)) return "broker";
+  return void 0;
+}
+function isRejectedPartyValue(value) {
+  const clean = normalizeWhitespace3(value);
+  return /^(?:and address|of record|insurer|carrier|security|broker|producer|agent|the|a|an|is|are|was|were|agrees?|means?|includes?|shall|will)\b/i.test(clean);
+}
+function identityWithoutAddress(value) {
+  const clean = cleanValue(value.replace(/\b(?:phone|tel|telephone|email|e-mail)\b.*$/i, "").replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b.*$/i, ""));
+  if (!clean) return void 0;
+  const beforeStreet = clean.match(/^(.+?)\s+\d{1,6}\s+[A-Za-z0-9.'-]+(?:\s+[A-Za-z0-9.'-]+){0,5}\s+(?:street|st\.?|avenue|ave\.?|road|rd\.?|drive|dr\.?|lane|ln\.?|boulevard|blvd\.?|suite|ste\.?|floor|fl\.?|way|court|ct\.?)\b/i)?.[1];
+  const beforeCityState = clean.match(/^(.+?)\s+[A-Z][A-Za-z.'-]+(?:\s+[A-Z][A-Za-z.'-]+)*,\s*[A-Z]{2}\s+\d{5}(?:-\d{4})?\b/)?.[1];
+  return cleanValue(beforeStreet ?? beforeCityState ?? clean);
+}
+function cleanPartyIdentity(value, clean) {
+  const raw = cleanValue(value);
+  if (!raw || isRejectedPartyValue(raw)) return void 0;
+  const identity = identityWithoutAddress(raw);
+  const cleaned = identity ? clean(identity) : void 0;
+  if (!cleaned || isRejectedPartyValue(cleaned)) return void 0;
+  return {
+    value: cleaned,
+    ...cleaned !== raw ? { normalizedValue: cleaned } : {}
+  };
+}
+function partyFromTableRows(nodes, wanted, clean) {
+  const children = childMap(nodes);
+  for (const row of compactFactNodes(nodes).filter((node) => node.kind === "table_row")) {
+    const cells = cellRows(row, children);
+    for (const [index, cell] of cells.entries()) {
+      const labelKind = partyLabelKind(cell.value) ?? partyLabelKind(cell.label);
+      if (labelKind !== wanted) continue;
+      const valueCell = cells.slice(index + 1).find((candidate) => !partyLabelKind(candidate.value) && !partyLabelKind(candidate.label));
+      if (!valueCell) continue;
+      const cleaned = cleanPartyIdentity(valueCell.value, clean);
+      if (cleaned) return valueFromNodes([row, valueCell.node], cleaned.value, "high", cleaned.normalizedValue);
+    }
+    const parts = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row)).split(/\s+\|\s+|\t/).map(cleanValue).filter((part) => Boolean(part));
+    for (const [index, part] of parts.entries()) {
+      const labelKind = partyLabelKind(part);
+      if (labelKind !== wanted) continue;
+      const cleaned = cleanPartyIdentity(parts[index + 1] ?? "", clean);
+      if (cleaned) return valueFromNodes([row], cleaned.value, "high", cleaned.normalizedValue);
+    }
+  }
+  return void 0;
+}
 function namedInsuredFromNodes(nodes) {
-  return firstCleanMatch(nodes, [
-    /\b(?:named insured|insured name|insured persons?|insured person)\s*:?\s*(.+?)(?=\s+(?:insurance amount|benefit amount|policy number|policy date|owner|beneficiary|premium|coverage|risk classification|date this)\b|[|;\n]|$)/i,
+  return partyFromTableRows(nodes, "namedInsured", cleanNamedInsured) ?? firstCleanMatch(nodes, [
+    /\b(?:named insured|insured name)\s*:?\s*(.+?)(?=\s+(?:insurance amount|benefit amount|policy number|policy date|owner|beneficiary|premium|coverage|risk classification|date this)\b|[|;\n]|$)/i,
+    /\b(?:insured persons?|insured person)\s*:\s*(.+?)(?=\s+(?:insurance amount|benefit amount|policy number|policy date|owner|beneficiary|premium|coverage|risk classification|date this)\b|[|;\n]|$)/i,
     /\b(?:applicant|policyholder)\s*:?\s*(.+?)(?=\s+(?:coverage|policy number|insurer|carrier|premium|effective|expiration)\b|[|;\n]|$)/i
   ], cleanNamedInsured);
 }
 function cleanInsurer(value) {
   const clean = cleanValue(value);
   if (!clean || clean.length > 140) return void 0;
-  if (/^(mean|means|we|us|our)\b/i.test(clean)) return void 0;
+  if (/^(mean|means|we|us|our|the|a|an|agrees?|shall|will)\b/i.test(clean)) return void 0;
   if (/\b(table of contents|policy wording|provided solely|convenience)\b/i.test(clean)) return void 0;
   const known = clean.match(/\b(Sun Life Assurance Company of Canada|Manulife|The Manufacturers Life Insurance Company)\b/i)?.[1];
   return known ?? clean;
 }
 function insurerFromNodes(nodes) {
+  const tableValue = partyFromTableRows(nodes, "insurer", cleanInsurer);
+  if (tableValue) return tableValue;
+  for (const node of compactFactNodes(nodes)) {
+    const text = nodeText(node);
+    const value = cleanInsurer(text.match(/\b([A-Z][A-Za-z&.,' -]{2,120}?(?:Insurance|Assurance|Indemnity|Casualty|Underwriting|Mutual|Risk|Reinsurance)\s+Company(?:\s+of\s+[A-Z][A-Za-z .'-]+)?)\s*\(\s*the\s+["']?Insurer["']?\s*\)/i)?.[1] ?? "");
+    if (value) return valueFromNode(node, value, "high");
+  }
   return firstCleanMatch(nodes, [
     /\bunderwritten by\s+([^|;\n.]{3,160})/i,
     /\b(?:insurer|carrier|company|security)\s*:?\s*([^|;\n]{3,120})/i,
@@ -3460,6 +3546,19 @@ function coverageNameFromRow(text) {
   );
   return cleanCoverageLabel(first);
 }
+function isDeclarationLimitLabel(value) {
+  const label = normalizeLabel(value);
+  return /\bitem\s*\d+[.)]?\s*limits?\s+of\s+liability\b/.test(label) || /^limits?\s+of\s+liability$/.test(label) || /^policy\s+limits?$/.test(label);
+}
+function declarationCoverageNameFromRow(row, children) {
+  const cells = cellRows(row, children);
+  const candidates = [
+    row.title,
+    ...cells.flatMap((cell) => [cell.label, cell.value])
+  ];
+  if (!candidates.some(isDeclarationLimitLabel)) return void 0;
+  return candidates.some((candidate) => /\blimits?\s+of\s+liability\b/i.test(candidate ?? "")) ? "Limits of Liability" : "Policy Limits";
+}
 function limitFromText(text) {
   return moneyValue(
     text.match(/\b(?:limit|liability|aggregate|occurrence|claim)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?|\$?\d[\d,]*\s*(?:each|per|aggregate)[^|;]*)/i)?.[1] ?? text.match(/(\$\s?\d[\d,]*(?:\.\d{2})?)(?=.*\b(limit|aggregate|occurrence|claim|liability)\b)/i)?.[1]
@@ -3469,10 +3568,22 @@ function deductibleFromText(text) {
   return moneyValue(text.match(/\b(?:deductible|retention|sir)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i)?.[1]);
 }
 function premiumFromText(text) {
-  return moneyValue(text.match(/\b(?:premium|total premium|total cost|amount due)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i)?.[1]);
+  return premiumValue(text.match(/\b(?:premium|total premium|total cost|amount due)\b(?:\s*(?:is|:|-))?\s*(\$?(?:\d[\d,]*(?:\.\d{2})?|X{2,}(?:,X{3})*(?:\.X{2})?))/i)?.[1]);
+}
+function premiumFromNodes(nodes) {
+  for (const node of compactFactNodes(nodes)) {
+    const value = premiumFromText(nodeText(node));
+    if (value) return valueFromNode(node, value, "high");
+  }
+  return void 0;
 }
 function moneyAmount(value) {
-  const match = value?.match(/\$?\s*([0-9][0-9,]*(?:\.\d+)?)/);
+  const clean = cleanValue(value);
+  if (!clean) return void 0;
+  const currency = clean.match(/\$\s*([0-9][0-9,]*(?:\.\d+)?)/);
+  const percent = clean.match(/\b([0-9][0-9,]*(?:\.\d+)?)\s*%/);
+  const explicitNumeric = !/\bitem\s*\d+\b/i.test(clean) && /\b(?:limit|aggregate|claim|occurrence|loss|retention|deductible|sir|premium|amount)\b/i.test(clean) ? clean.match(/\b([0-9][0-9,]*(?:\.\d+)?)\b/) : void 0;
+  const match = currency ?? percent ?? explicitNumeric;
   if (!match) return void 0;
   const amount = Number(match[1].replace(/,/g, ""));
   return Number.isFinite(amount) ? amount : void 0;
@@ -3518,6 +3629,10 @@ function isValueCell(label, value) {
   }
   return /\b(limit|aggregate|retention|deductible|sir|retroactive|premium|amount)\b/.test(normalizedLabel) || moneyAmount(value) !== void 0 || /\b(full prior acts|none|included|not included|as stated)\b/.test(normalizedValue);
 }
+function isCoverageTermLabel(value) {
+  const label = normalizeLabel(value);
+  return /\b(limit|aggregate|retention|deductible|sir|retroactive|premium|amount|sub[-\s]?limit)\b/.test(label);
+}
 function isNameCell(label, value) {
   const normalizedLabel = normalizeLabel(label);
   const normalizedValue = normalizeLabel(value);
@@ -3619,6 +3734,16 @@ function termFromCell(params) {
 function termsFromRow(row, children) {
   const cells = cellRows(row, children);
   if (cells.length > 0) {
+    const pairedTerms = [];
+    for (const [index, cell] of cells.entries()) {
+      const next = cells[index + 1];
+      if (!next) continue;
+      if (!isCoverageTermLabel(cell.value)) continue;
+      if (isCoverageTermLabel(next.value) && moneyAmount(next.value) === void 0) continue;
+      const term = termFromCell({ row, cell: next.node, label: cell.value, value: next.value });
+      if (term) pairedTerms.push(term);
+    }
+    if (pairedTerms.length > 0) return pairedTerms;
     return cells.filter((cell) => isValueCell(cell.label, cell.value)).map((cell) => termFromCell({ row, cell: cell.node, label: cell.label, value: cell.value })).filter((term) => Boolean(term));
   }
   const text = normalizeWhitespace3(row.textExcerpt ?? row.description ?? nodeText(row));
@@ -3645,6 +3770,8 @@ function termsFromRow(row, children) {
   return terms;
 }
 function nameFromRow(row, children) {
+  const declarationName = declarationCoverageNameFromRow(row, children);
+  if (declarationName) return declarationName;
   const cells = cellRows(row, children);
   const named = cells.find((cell) => isNameCell(cell.label, cell.value));
   if (named) return cleanValue(named.value);
@@ -3822,7 +3949,7 @@ function buildParties(profile) {
   if (profile.namedInsured) {
     parties.push({
       role: "named_insured",
-      name: profile.namedInsured.value,
+      name: profile.namedInsured.normalizedValue ?? profile.namedInsured.value,
       sourceNodeIds: profile.namedInsured.sourceNodeIds,
       sourceSpanIds: profile.namedInsured.sourceSpanIds
     });
@@ -3830,7 +3957,7 @@ function buildParties(profile) {
   if (profile.insurer) {
     parties.push({
       role: "insurer",
-      name: profile.insurer.value,
+      name: profile.insurer.normalizedValue ?? profile.insurer.value,
       sourceNodeIds: profile.insurer.sourceNodeIds,
       sourceSpanIds: profile.insurer.sourceSpanIds
     });
@@ -3838,7 +3965,7 @@ function buildParties(profile) {
   if (profile.broker) {
     parties.push({
       role: "broker",
-      name: profile.broker.value,
+      name: profile.broker.normalizedValue ?? profile.broker.value,
       sourceNodeIds: profile.broker.sourceNodeIds,
       sourceSpanIds: profile.broker.sourceSpanIds
     });
@@ -3891,9 +4018,7 @@ function buildDeterministicOperationalProfile(params) {
     retroactiveDate: firstMatch(nodes, [
       /\bretroactive date\s*:?\s*([0-9]{1,2}[/-][0-9]{1,2}[/-][0-9]{2,4}|full prior acts|none)/i
     ]),
-    premium: firstMatch(nodes, [
-      /\b(?:total premium|premium|total cost|amount due)\s*:?\s*(\$?\d[\d,]*(?:\.\d{2})?)/i
-    ])
+    premium: premiumFromNodes(nodes)
   };
   const coverages = buildCoverages(nodes);
   const coverageTypes = [...new Set(coverages.map((coverage) => coverage.name))];
@@ -11277,9 +11402,19 @@ function sourceTreeToOutline(sourceTree) {
   });
   return (byParent.get(root?.id) ?? []).map(visit);
 }
+var NORMALIZED_COMPATIBILITY_FIELDS = /* @__PURE__ */ new Set([
+  "policyNumber",
+  "namedInsured",
+  "insurer",
+  "broker"
+]);
 function valueOf(profile, key) {
   const value = profile[key];
-  return value && typeof value === "object" && !Array.isArray(value) && "value" in value ? String(value.value) : void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value) || !("value" in value)) return void 0;
+  if (NORMALIZED_COMPATIBILITY_FIELDS.has(key) && "normalizedValue" in value && typeof value.normalizedValue === "string" && value.normalizedValue.trim()) {
+    return value.normalizedValue;
+  }
+  return String(value.value);
 }
 function materializeDocument(params) {
   const profile = params.operationalProfile;