@beyondwork/docx-react-component 1.0.27 → 1.0.29

package/dist/legal/index.js

@@ -0,0 +1,616 @@
+import {
+  parseMainDocumentXml
+} from "../chunk-4AQOYAW4.js";
+import "../chunk-FUDY333O.js";
+import {
+  assessBookmarkIntegrity,
+  collectBookmarksFromCanonicalDocument,
+  isHiddenBookmarkName,
+  parseBookmarksFromDocumentXml
+} from "../chunk-RMH72RZI.js";
+import {
+  extractComplexFieldsFromBodyXml,
+  parseFieldsFromParagraphXml
+} from "../chunk-TLCEAQDQ.js";
+
+// src/legal/cross-references.ts
+var CROSS_REFERENCE_PATTERN = /\b(Section|Clause|Article|Schedule|Exhibit|Appendix)\s+(\d+(?:\.\d+)*|[A-Z]-\d+|[A-Z])(?=[^A-Za-z0-9]|$)/g;
+var W_REF_PATTERN = /<w:ref\b([^>]*)\/?>/g;
+var ATTRIBUTE_PATTERN = /(?:^|\s)(?:w:)?([A-Za-z][\w-]*)="([^"]*)"/g;
+var COMPLEX_FIELD_PATTERN = /<w:instrText\b[^>]*>([\s\S]*?)<\/w:instrText>[\s\S]*?<w:fldChar\b[^>]*w:fldCharType="separate"[^>]*\/>[\s\S]*?<w:t\b[^>]*>([\s\S]*?)<\/w:t>[\s\S]*?<w:fldChar\b[^>]*w:fldCharType="end"[^>]*\/>/g;
+function parseCrossReferencesFromDocumentXml(xml) {
+  const parsed = parseMainDocumentXml(xml);
+  const results = [];
+  parsed.blocks.forEach((block, paragraphIndex) => {
+    if (block.type !== "paragraph") {
+      return;
+    }
+    for (const child of block.children) {
+      if (child.type === "hyperlink" && child.href.startsWith("#")) {
+        results.push({
+          source: "hyperlink",
+          kind: "bookmark",
+          target: child.href.slice(1),
+          label: flattenInlineText(child.children).trim() || child.href.slice(1),
+          paragraphIndex,
+          confidence: "high"
+        });
+      }
+    }
+    const { simpleFields } = parseFieldsFromParagraphXml(block.rawXml);
+    for (const field of simpleFields) {
+      const reference = parseFieldReferenceInstruction(field.instruction);
+      if (!reference) {
+        continue;
+      }
+      results.push({
+        source: "field",
+        kind: "bookmark",
+        target: reference.target,
+        instruction: reference.instruction,
+        label: stripXml(field.contentXml) || reference.target,
+        paragraphIndex,
+        confidence: "high"
+      });
+    }
+    for (const pattern of detectCrossReferencePatterns(flattenParagraphText(block))) {
+      results.push({
+        source: "text-pattern",
+        kind: pattern.kind,
+        target: pattern.targetHint,
+        label: pattern.label,
+        paragraphIndex,
+        confidence: "medium"
+      });
+    }
+  });
+  for (const field of extractComplexFieldsFromBodyXml(xml)) {
+    const reference = parseFieldReferenceInstruction(field.instruction);
+    if (!reference) {
+      continue;
+    }
+    results.push({
+      source: "field",
+      kind: "bookmark",
+      target: reference.target,
+      instruction: reference.instruction,
+      label: stripXml(field.contentXml) || reference.target,
+      confidence: "high"
+    });
+  }
+  for (const field of extractComplexFieldsWithRegex(xml)) {
+    const reference = parseFieldReferenceInstruction(field.instruction);
+    if (!reference) {
+      continue;
+    }
+    results.push({
+      source: "field",
+      kind: "bookmark",
+      target: reference.target,
+      instruction: reference.instruction,
+      label: field.label || reference.target,
+      confidence: "high"
+    });
+  }
+  for (const element of extractWRefElements(xml)) {
+    results.push({
+      source: "w:ref",
+      kind: "bookmark",
+      target: element.target,
+      label: element.label || element.target || "w:ref",
+      confidence: element.target ? "high" : "medium"
+    });
+  }
+  return dedupeCrossReferences(results);
+}
+function collectCrossReferencesFromCanonicalDocument(document) {
+  const root = "content" in document ? document.content : document;
+  const results = [];
+  let paragraphIndex = -1;
+  walkDocument(root, (node) => {
+    if (node.type === "paragraph") {
+      paragraphIndex += 1;
+      for (const child of node.children) {
+        if (child.type === "hyperlink" && child.href.startsWith("#")) {
+          results.push({
+            source: "hyperlink",
+            kind: "bookmark",
+            target: child.href.slice(1),
+            label: flattenInlineText(child.children).trim() || child.href.slice(1),
+            paragraphIndex,
+            confidence: "high"
+          });
+          continue;
+        }
+        if (child.type === "field") {
+          const reference = parseFieldReferenceInstruction(child.instruction);
+          if (!reference) {
+            continue;
+          }
+          results.push({
+            source: "field",
+            kind: "bookmark",
+            target: reference.target,
+            instruction: reference.instruction,
+            label: flattenInlineText(child.children).trim() || reference.target,
+            paragraphIndex,
+            confidence: "high"
+          });
+        }
+      }
+      for (const pattern of detectCrossReferencePatterns(flattenParagraphText(node))) {
+        results.push({
+          source: "text-pattern",
+          kind: pattern.kind,
+          target: pattern.targetHint,
+          label: pattern.label,
+          paragraphIndex,
+          confidence: "medium"
+        });
+      }
+    }
+  });
+  return dedupeCrossReferences(results);
+}
+function detectCrossReferencePatterns(text) {
+  const matches = [];
+  for (const match of text.matchAll(CROSS_REFERENCE_PATTERN)) {
+    const referenceType = match[1]?.toLowerCase();
+    const target = match[2];
+    const label = `${match[1]} ${target}`.trim();
+    if (!referenceType || !target) {
+      continue;
+    }
+    matches.push({
+      kind: referenceType,
+      label,
+      targetHint: target
+    });
+  }
+  return matches;
+}
+function parseFieldReferenceInstruction(instruction) {
+  const trimmedInstruction = instruction.trim().replace(/\s+/g, " ");
+  const match = /^(REF|PAGEREF|NOTEREF)\s+(?:"([^"]+)"|([^\s\\]+))/i.exec(trimmedInstruction);
+  if (!match) {
+    return void 0;
+  }
+  return {
+    kind: match[1].toUpperCase(),
+    target: (match[2] ?? match[3] ?? "").trim(),
+    instruction: trimmedInstruction
+  };
+}
+function extractWRefElements(xml) {
+  const matches = [];
+  for (const match of xml.matchAll(W_REF_PATTERN)) {
+    const attributes = readAttributes(match[1] ?? "");
+    matches.push({
+      target: attributes.anchor ?? attributes.name ?? attributes.id,
+      label: attributes.displayText ?? attributes.text
+    });
+  }
+  return matches;
+}
+function extractComplexFieldsWithRegex(xml) {
+  const matches = [];
+  for (const match of xml.matchAll(COMPLEX_FIELD_PATTERN)) {
+    const instruction = stripXml(match[1] ?? "");
+    const label = stripXml(match[2] ?? "");
+    if (!instruction) {
+      continue;
+    }
+    matches.push({ instruction, label });
+  }
+  return matches;
+}
+function readAttributes(source) {
+  const attributes = {};
+  for (const match of source.matchAll(ATTRIBUTE_PATTERN)) {
+    const [, key, value] = match;
+    attributes[key] = value;
+  }
+  return attributes;
+}
+function stripXml(xml) {
+  return xml.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+function flattenParagraphText(paragraph) {
+  return paragraph.children.map((child) => {
+    switch (child.type) {
+      case "text":
+        return child.text;
+      case "hyperlink":
+        return flattenInlineText(child.children);
+      case "field":
+        return child.children ? flattenInlineText(child.children) : "";
+      case "tab":
+        return "	";
+      case "hard_break":
+      case "column_break":
+        return "\n";
+      default:
+        return "";
+    }
+  }).join("");
+}
+function flattenInlineText(children) {
+  return children.map((child) => {
+    if (child.type === "text") {
+      return child.text;
+    }
+    if (child.type === "tab") {
+      return "	";
+    }
+    if (child.type === "hard_break" || child.type === "column_break") {
+      return "\n";
+    }
+    return "";
+  }).join("");
+}
+function dedupeCrossReferences(references) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const reference of references) {
+    const key = [
+      reference.source,
+      reference.kind,
+      reference.target ?? "",
+      reference.label,
+      String(reference.paragraphIndex ?? -1)
+    ].join("|");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(reference);
+  }
+  return deduped;
+}
+function walkDocument(node, visit) {
+  visit(node);
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkDocument(child, visit);
+    }
+  }
+  if (node.type === "table") {
+    for (const row of node.rows) {
+      walkDocument(row, visit);
+    }
+  } else if (node.type === "table_row") {
+    for (const cell of node.cells) {
+      walkDocument(cell, visit);
+    }
+  }
+}
+
+// src/legal/defined-terms.ts
+var QUOTED_DEFINITION_PATTERN = /["“]([A-Z][A-Za-z0-9]*(?:[ -][A-Z][A-Za-z0-9]*){0,5})["”]\s+(?:means|has the meaning(?: set forth)?|shall mean|refers to)\b/g;
+var BARE_DEFINITION_PATTERN = /\b([A-Z][A-Za-z0-9]*(?:\s+[A-Z][A-Za-z0-9]*){0,5})\s+(?:means|has the meaning(?: set forth)?|shall mean|refers to)\b/g;
+var BLOCKED_BARE_TERMS = /* @__PURE__ */ new Set([
+  "This Agreement",
+  "Such Term",
+  "The Company",
+  "This Section",
+  "This Clause"
+]);
+function collectDefinedTermsFromDocumentXml(xml) {
+  const parsed = parseMainDocumentXml(xml);
+  const paragraphs = parsed.blocks.filter((block) => block.type === "paragraph").map((block) => flattenParagraphText2(block));
+  return buildDefinedTermCatalog(paragraphs);
+}
+function collectDefinedTermsFromCanonicalDocument(document) {
+  const root = "content" in document ? document.content : document;
+  const paragraphs = [];
+  walkDocument2(root, (node) => {
+    if (node.type === "paragraph") {
+      paragraphs.push(flattenParagraphText2(node));
+    }
+  });
+  return buildDefinedTermCatalog(paragraphs);
+}
+function buildDefinedTermCatalog(paragraphs) {
+  const terms = /* @__PURE__ */ new Map();
+  paragraphs.forEach((paragraph, paragraphIndex) => {
+    for (const candidate of extractDefinitionCandidates(paragraph)) {
+      const normalized = normalizeTerm(candidate.term);
+      const existing = terms.get(normalized) ?? {
+        term: candidate.term,
+        normalizedTerm: normalized,
+        definitionStyle: candidate.definitionStyle,
+        definitions: [],
+        references: []
+      };
+      if (!terms.has(normalized)) {
+        terms.set(normalized, existing);
+      }
+      existing.definitions.push({
+        paragraphIndex,
+        label: candidate.term,
+        kind: "definition"
+      });
+    }
+  });
+  paragraphs.forEach((paragraph, paragraphIndex) => {
+    for (const term of terms.values()) {
+      const references = findTermReferences(paragraph, term.term);
+      if (references === 0) {
+        continue;
+      }
+      const hasDefinitionInParagraph = term.definitions.some(
+        (definition) => definition.paragraphIndex === paragraphIndex
+      );
+      const referenceCount = hasDefinitionInParagraph ? 0 : references;
+      for (let count = 0; count < referenceCount; count += 1) {
+        term.references.push({
+          paragraphIndex,
+          label: term.term,
+          kind: "reference"
+        });
+      }
+    }
+  });
+  return Array.from(terms.values()).sort((left, right) => left.term.localeCompare(right.term));
+}
+function extractDefinitionCandidates(paragraph) {
+  const candidates = [];
+  for (const match of paragraph.matchAll(QUOTED_DEFINITION_PATTERN)) {
+    const term = match[1]?.trim();
+    if (!term) {
+      continue;
+    }
+    candidates.push({
+      term,
+      definitionStyle: "quoted"
+    });
+  }
+  for (const match of paragraph.matchAll(BARE_DEFINITION_PATTERN)) {
+    const term = match[1]?.trim();
+    if (!term || BLOCKED_BARE_TERMS.has(term) || isQuotedTerm(term, paragraph)) {
+      continue;
+    }
+    candidates.push({
+      term,
+      definitionStyle: "bare"
+    });
+  }
+  return candidates;
+}
+function normalizeTerm(term) {
+  return term.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function isQuotedTerm(term, paragraph) {
+  return paragraph.includes(`"${term}"`) || paragraph.includes(`\u201C${term}\u201D`);
+}
+function findTermReferences(paragraph, term) {
+  const escapedTerm = escapeRegExp(term);
+  const pattern = new RegExp(`(?:^|[^A-Za-z0-9])(?:"|\u201C)?(${escapedTerm})(?:"|\u201D)?(?=[^A-Za-z0-9]|$)`, "g");
+  return Array.from(paragraph.matchAll(pattern)).length;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function flattenParagraphText2(paragraph) {
+  return paragraph.children.map((child) => {
+    switch (child.type) {
+      case "text":
+        return child.text;
+      case "hyperlink":
+      case "field":
+        return child.children.map((nested) => nested.type === "text" ? nested.text : nested.type === "tab" ? "	" : "").join("");
+      case "tab":
+        return "	";
+      case "hard_break":
+      case "column_break":
+        return "\n";
+      default:
+        return "";
+    }
+  }).join("");
+}
+function walkDocument2(node, visit) {
+  visit(node);
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkDocument2(child, visit);
+    }
+  }
+  if (node.type === "table") {
+    for (const row of node.rows) {
+      walkDocument2(row, visit);
+    }
+  } else if (node.type === "table_row") {
+    for (const cell of node.cells) {
+      walkDocument2(cell, visit);
+    }
+  }
+}
+
+// src/legal/signature-blocks.ts
+var EXECUTION_TRIGGER_PATTERN = /\b(?:IN WITNESS WHEREOF|EXECUTED|AGREED AND ACCEPTED|SIGNATURES FOLLOW)\b/i;
+var ROLE_LINE_PATTERN = /^\s*(?:By|Name|Title|Date|Witness|Authorized Signatory|Signature)\s*[:\-]?\s*/i;
+var PARTY_LABEL_PATTERN = /^(?:(?:The |)[A-Z][A-Za-z0-9 ,.'&()-]{2,60})\s*$/;
+var WITNESS_PATTERN = /\bWITNESS(?:ED|ES)?\b/i;
+var NOTARY_PATTERN = /\bNOTARY\s+PUBLIC\b/i;
+var UNDERLINE_PLACEHOLDER_PATTERN = /_{4,}|\.{4,}/;
+function detectSignatureBlocksFromCanonicalDocument(document) {
+  const root = "content" in document ? document.content : document;
+  const paragraphs = [];
+  const warnings = [];
+  walkBlocks(root, (node) => {
+    if (node.type === "paragraph") {
+      paragraphs.push({ text: flattenParagraphText3(node), node });
+    }
+  });
+  const candidates = findSignatureBlockCandidates(paragraphs);
+  const hasPreservation = "preservation" in document && document.preservation !== void 0;
+  const preservationSafe = hasPreservation ? !hasOpaqueFragmentsInSignatureRanges(
+    document,
+    candidates
+  ) : true;
+  if (!preservationSafe) {
+    warnings.push(
+      "One or more signature block regions overlap with preserve-only opaque fragments. Export fidelity may be degraded."
+    );
+  }
+  return {
+    reportVersion: "signature-block-report/1",
+    candidates,
+    preservationSafe,
+    warnings
+  };
+}
+function findSignatureBlockCandidates(paragraphs) {
+  const candidates = [];
+  let index = 0;
+  while (index < paragraphs.length) {
+    const text = paragraphs[index].text;
+    if (EXECUTION_TRIGGER_PATTERN.test(text)) {
+      const block = scanSignatureBlock(paragraphs, index);
+      if (block) {
+        candidates.push(block);
+        index = block.endIndex + 1;
+        continue;
+      }
+    }
+    index += 1;
+  }
+  return candidates;
+}
+function scanSignatureBlock(paragraphs, triggerIndex) {
+  const parties = [];
+  let endIndex = triggerIndex;
+  let kind = "execution-block";
+  let hasSignatureContent = false;
+  for (let index = triggerIndex + 1; index < paragraphs.length && index <= triggerIndex + 40; index += 1) {
+    const text = paragraphs[index].text.trim();
+    if (text.length === 0) {
+      endIndex = index;
+      continue;
+    }
+    if (WITNESS_PATTERN.test(text)) {
+      kind = "witness-block";
+    }
+    if (NOTARY_PATTERN.test(text)) {
+      kind = "notary-block";
+    }
+    if (ROLE_LINE_PATTERN.test(text)) {
+      hasSignatureContent = true;
+      endIndex = index;
+      continue;
+    }
+    if (UNDERLINE_PLACEHOLDER_PATTERN.test(text)) {
+      hasSignatureContent = true;
+      endIndex = index;
+      continue;
+    }
+    if (PARTY_LABEL_PATTERN.test(text) && !isBodyParagraph(text)) {
+      parties.push({
+        roleLabel: text.trim(),
+        paragraphIndex: index
+      });
+      hasSignatureContent = true;
+      endIndex = index;
+      continue;
+    }
+    if (hasSignatureContent && isBodyParagraph(text)) {
+      break;
+    }
+    endIndex = index;
+  }
+  if (!hasSignatureContent) {
+    return void 0;
+  }
+  return {
+    startIndex: triggerIndex,
+    endIndex,
+    kind,
+    parties,
+    confidence: parties.length > 0 ? "high" : "medium"
+  };
+}
+function isBodyParagraph(text) {
+  return text.length > 120 && /[.;]/.test(text);
+}
+function hasOpaqueFragmentsInSignatureRanges(document, candidates) {
+  if (candidates.length === 0) {
+    return false;
+  }
+  const opaqueCount = Object.keys(document.preservation.opaqueFragments).length;
+  if (opaqueCount === 0) {
+    return false;
+  }
+  let paragraphIndex = 0;
+  const opaqueIndices = /* @__PURE__ */ new Set();
+  for (const block of document.content.children) {
+    if (block.type === "paragraph") {
+      paragraphIndex += 1;
+      continue;
+    }
+    if (block.type === "opaque_block") {
+      opaqueIndices.add(paragraphIndex);
+    }
+    paragraphIndex += 1;
+  }
+  return candidates.some((candidate) => {
+    for (let index = candidate.startIndex; index <= candidate.endIndex; index += 1) {
+      if (opaqueIndices.has(index)) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+function flattenParagraphText3(paragraph) {
+  return paragraph.children.map((child) => {
+    switch (child.type) {
+      case "text":
+        return child.text;
+      case "hyperlink":
+      case "field":
+        return child.children.map(
+          (nested) => nested.type === "text" ? nested.text : nested.type === "tab" ? "	" : ""
+        ).join("");
+      case "tab":
+        return "	";
+      case "hard_break":
+      case "column_break":
+        return "\n";
+      default:
+        return "";
+    }
+  }).join("");
+}
+function walkBlocks(node, visit) {
+  visit(node);
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkBlocks(child, visit);
+    }
+  }
+  if (node.type === "table") {
+    for (const row of node.rows) {
+      walkBlocks(row, visit);
+    }
+  } else if (node.type === "table_row") {
+    for (const cell of node.cells) {
+      walkBlocks(cell, visit);
+    }
+  }
+}
+export {
+  assessBookmarkIntegrity,
+  buildDefinedTermCatalog,
+  collectBookmarksFromCanonicalDocument,
+  collectCrossReferencesFromCanonicalDocument,
+  collectDefinedTermsFromCanonicalDocument,
+  collectDefinedTermsFromDocumentXml,
+  detectCrossReferencePatterns,
+  detectSignatureBlocksFromCanonicalDocument,
+  isHiddenBookmarkName,
+  parseBookmarksFromDocumentXml,
+  parseCrossReferencesFromDocumentXml,
+  parseFieldReferenceInstruction
+};
+//# sourceMappingURL=index.js.map