61:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 62:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/1bpgyrs5qflhu.js","/_next/static/immutable/chunks/0-6vu2ul1h6ld.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 63:T23c2,import { redline, type RedlineSegment } from "./redline"; import { blockById, type Doc } from "./types"; /** * A durable pointer at a span of one block's text, for comments and AI suggestions. It keeps * offsets for speed and a quote with context (like the W3C TextQuoteSelector) so it can be * found again after the text changes. */ export type TextAnchor = { id: string; blockId: string; start: number; end: number; /** The anchored text when created. */ quote: string; /** Up to `context` characters either side, to disambiguate repeated phrases. */ prefix: string; suffix: string; }; export type Comment = TextAnchor & { kind: "comment"; author: string; body: string; /** Epoch ms. */ createdAt: number; resolved?: boolean; /** Replies, oldest first. */ replies?: { id: string; author: string; body: string; createdAt: number }[]; }; export type Suggestion = TextAnchor & { kind: "suggestion"; /** The text proposed in place of `quote` (empty to delete it). */ replacement: string; /** Why: "Caps liability at 12 months' fees, per playbook §3." */ rationale?: string; author?: string; /** 0–1, for AI suggestions. */ confidence?: number; status: "pending" | "accepted" | "rejected"; }; /** An anchor over `block.text.slice(start, end)`. */ export function createAnchor(doc: Doc, blockId: string, start: number, end: number, { id, context = 24 }: { id: string; context?: number }): TextAnchor { const text = blockById(doc, blockId)?.text ?? ""; const s = Math.max(0, Math.min(start, end, text.length)); const e = Math.min(text.length, Math.max(start, end)); return { id, blockId, start: s, end: e, quote: text.slice(s, e), prefix: text.slice(Math.max(0, s - context), s), suffix: text.slice(e, e + context) }; } /** An anchor over the first occurrence of `quote` in a block (after `from`): handy for fixtures and AI output that cites text. */ export function anchorQuote(doc: Doc, blockId: string, quote: string, { id, from = 0, context }: { id: string; from?: number; context?: number }): TextAnchor | null { const text = blockById(doc, blockId)?.text ?? ""; const i = text.indexOf(quote, from); return i < 0 ? null : createAnchor(doc, blockId, i, i + quote.length, { id, context }); } export type ResolvedAnchor = { blockId: string; start: number; end: number; status: "exact" | "moved" | "orphaned" }; /** * Where an anchor points in `doc` now: `exact` when the offsets still hold the quote, `moved` * when the quote was found elsewhere (the occurrence whose context matches best, nearest the * old offset), `orphaned` when the quoted text is gone (show it as "on deleted text"). */ export function resolveAnchor(doc: Doc, anchor: TextAnchor): ResolvedAnchor { const home = blockById(doc, anchor.blockId); if (home && home.text.slice(anchor.start, anchor.end) === anchor.quote) return { blockId: home.id, start: anchor.start, end: anchor.end, status: "exact" }; if (!anchor.quote) return { blockId: anchor.blockId, start: 0, end: 0, status: "orphaned" }; const candidates = home ? [home, ...doc.blocks.filter((b) => b !== home)] : doc.blocks; let best: { blockId: string; start: number; score: number } | null = null; for (const b of candidates) { for (let i = b.text.indexOf(anchor.quote); i >= 0; i = b.text.indexOf(anchor.quote, i + 1)) { const before = b.text.slice(Math.max(0, i - anchor.prefix.length), i); const after = b.text.slice(i + anchor.quote.length, i + anchor.quote.length + anchor.suffix.length); const score = sharedSuffix(before, anchor.prefix) + sharedPrefix(after, anchor.suffix) + (b.id === anchor.blockId ? 1000 - Math.min(999, Math.abs(i - anchor.start)) / 1000 : 0); if (!best || score > best.score) best = { blockId: b.id, start: i, score }; } } return best ? { blockId: best.blockId, start: best.start, end: best.start + anchor.quote.length, status: "moved" } : { blockId: anchor.blockId, start: 0, end: 0, status: "orphaned" }; } const sharedPrefix = (a: string, b: string) => { let n = 0; while (n < a.length && n < b.length && a[n] === b[n]) n++; return n; }; const sharedSuffix = (a: string, b: string) => { let n = 0; while (n < a.length && n < b.length && a[a.length - 1 - n] === b[b.length - 1 - n]) n++; return n; }; /** * Maps an offset in the redline's "before" text to the "after" text. Offsets inside deleted * text land at the deletion point; `bias` decides which side of an insertion at the offset. */ export function mapOffset(offset: number, segments: readonly RedlineSegment[], bias: "before" | "after" = "after"): number { let a = 0; let b = 0; for (const s of segments) { if (s.kind === "insert") { if (a < offset || (a === offset && bias === "after")) b += s.text.length; continue; } const len = s.text.length; if (offset < a + len) return s.kind === "equal" ? b + (offset - a) : b; a += len; if (s.kind === "equal") b += len; } return b; } /** An anchor moved through an edit of its block (offsets mapped, quote and context refreshed). */ export function rebaseAnchor(anchor: A, before: string, after: string, segments = redline(before, after).segments): A { const start = mapOffset(anchor.start, segments, "after"); const end = Math.max(start, mapOffset(anchor.end, segments, "before")); const context = Math.max(anchor.prefix.length, anchor.suffix.length, 24); return { ...anchor, start, end, quote: after.slice(start, end), prefix: after.slice(Math.max(0, start - context), start), suffix: after.slice(end, end + context) }; } export type MarkedRun = { text: string; start: number; end: number; ids: string[] }; /** * A block's text cut into runs at every anchor edge, each run listing the anchors covering * it: render runs with `ids.length` as `` (overlaps nest naturally as multiple ids). */ export function splitByAnchors(text: string, anchors: readonly { id: string; start: number; end: number }[]): MarkedRun[] { const cuts = new Set([0, text.length]); for (const a of anchors) { cuts.add(Math.max(0, Math.min(text.length, a.start))); cuts.add(Math.max(0, Math.min(text.length, a.end))); } const points = [...cuts].sort((x, y) => x - y); const runs: MarkedRun[] = []; for (let i = 0; i < points.length - 1; i++) { const [s, e] = [points[i], points[i + 1]]; if (e <= s) continue; runs.push({ text: text.slice(s, e), start: s, end: e, ids: anchors.filter((a) => a.start < e && a.end > s).map((a) => a.id) }); } return runs; } /** * The anchored span of a DOM selection inside one rendered block. Blocks must render their * text verbatim inside an element with `data-doc-block={block.id}` (marks and ins are fine; * extra text such as clause numbers must sit outside it). Null for collapsed or cross-block * selections. */ export function anchorFromSelection(selection: Selection | null = typeof window === "undefined" ? null : window.getSelection()): { blockId: string; start: number; end: number; quote: string } | null { if (!selection || selection.rangeCount === 0 || selection.isCollapsed) return null; const range = selection.getRangeAt(0); const blockOf = (n: Node) => (n.nodeType === Node.ELEMENT_NODE ? (n as Element) : n.parentElement)?.closest("[data-doc-block]") ?? null; const block = blockOf(range.startContainer); if (!block || block !== blockOf(range.endContainer)) return null; const offsetOf = (node: Node, offset: number) => { const r = document.createRange(); r.selectNodeContents(block); r.setEnd(node, offset); return r.toString().length; }; const start = offsetOf(range.startContainer, range.startOffset); const end = offsetOf(range.endContainer, range.endOffset); return { blockId: block.dataset.docBlock!, start, end, quote: range.toString() }; } /** The block text with a suggestion applied, and its redline: render it inline or in an Approval Card. */ export function suggestionPreview(doc: Doc, s: Suggestion) { const block = blockById(doc, s.blockId); const at = resolveAnchor(doc, s); const before = block?.text ?? ""; const after = at.status === "orphaned" ? before : before.slice(0, at.start) + s.replacement + before.slice(at.end); return { before, after, anchor: at, redline: redline(before, after, { idPrefix: `${s.id}:` }) }; } /** * Accepts a suggestion: a new document with the replacement in place, and every other anchor * (comments, other suggestions) on that block rebased through the edit so it still points at * its text. */ export function applySuggestion (doc: Doc, s: Suggestion, others: readonly A[] = []): { doc: Doc; anchors: A[] } { const { before, after, anchor, redline: r } = suggestionPreview(doc, s); if (anchor.status === "orphaned") return { doc, anchors: [...others] }; const next: Doc = { ...doc, blocks: doc.blocks.map((b) => (b.id === anchor.blockId ? { ...b, text: after } : b)) }; const anchors = others.map((a) => (a.blockId === anchor.blockId && a.id !== s.id ? rebaseAnchor(a, before, after, r.segments) : a)); return { doc: next, anchors }; } 64:T25e9,import { diffChars, diffSentences, diffWords, diffWordsWithSpace, structuredPatch, type ChangeObject } from "diff"; import type { Doc, DocBlock } from "./types"; /** A run of text in an inline redline. Rendered as plain, `` or ``. */ export type RedlineSegment = { kind: "equal" | "insert" | "delete"; text: string; /** Inserts and deletes that form one edit share a change id (a replacement is a delete + an insert). */ changeId?: string; }; /** One reviewable edit: accept or reject it as a unit. */ export type RedlineChange = { id: string; kind: "insert" | "delete" | "replace"; deleted: string; inserted: string; }; export type Redline = { segments: RedlineSegment[]; changes: RedlineChange[]; /** Words added and removed, for "+12 −3". */ stats: { inserted: number; deleted: number; changes: number }; }; export type RedlineOptions = { /** `word` (default) reads like a lawyer's redline; `char` for codes and figures; `sentence` for long rewrites. */ granularity?: "word" | "char" | "sentence"; /** Word boundaries follow this locale's `Intl.Segmenter` (so "1.5%" changes as "1.5", not ".5"). Default the runtime's. */ locale?: string; /** Prefix for change ids, so two blocks' changes stay unique: `${prefix}${n}`. Default `c`. */ idPrefix?: string; }; const words = (s: string) => (s.match(/\S+/g) ?? []).length; /** * An inline redline between two strings on the `diff` package: segments for rendering, and * the edits grouped into changes you can accept or reject. A delete next to an insert is one * replacement, and up to three characters of space or punctuation between two edits are folded * in, so "three (3) months" → "twelve (12) months" reads as one change, not two. * * const { segments, changes, stats } = redline(clause.text, revised.text); */ export function redline(before: string, after: string, { granularity = "word", idPrefix = "c", locale }: RedlineOptions = {}): Redline { const raw: ChangeObject[] = granularity === "char" ? diffChars(before, after) : granularity === "sentence" ? diffSentences(before, after) : diffByWords(before, after, locale); // Group into runs: equal text, or a change (deleted + inserted), folding short space/punctuation equals between two changes. type Run = { equal: string } | { deleted: string; inserted: string }; const runs: Run[] = []; for (let i = 0; i < raw.length; i++) { const p = raw[i]; const last = runs[runs.length - 1]; if (!p.added && !p.removed) { const next = raw[i + 1]; const bridges = last && "deleted" in last && next && (next.added || next.removed) && /^[\s\p{P}]{1,3}$/u.test(p.value); if (bridges) { last.deleted += p.value; last.inserted += p.value; } else runs.push({ equal: p.value }); continue; } if (!last || "equal" in last) runs.push({ deleted: "", inserted: "" }); const run = runs[runs.length - 1] as { deleted: string; inserted: string }; if (p.removed) run.deleted += p.value; else run.inserted += p.value; } // A pure insert or delete takes the space before it with it, so rejecting "days of notice." // gives "days." and not "days ." (word diffs leave that space in the equal text). for (let i = 1; i < runs.length; i++) { const run = runs[i]; const prev = runs[i - 1]; const next = runs[i + 1]; if ("equal" in run || "deleted" in prev || (run.deleted && run.inserted)) continue; const text = run.deleted || run.inserted; const ws = /\s+$/.exec(prev.equal)?.[0]; if (!ws || /\s$/.test(text) || (next && "equal" in next && /^\s/.test(next.equal))) continue; prev.equal = prev.equal.slice(0, -ws.length); if (run.deleted) run.deleted = ws + run.deleted; else run.inserted = ws + run.inserted; } const segments: RedlineSegment[] = []; const changes: RedlineChange[] = []; let ins = 0; let del = 0; for (const run of runs) { if ("equal" in run) { segments.push({ kind: "equal", text: run.equal }); continue; } // Trim the whitespace both sides share at the ends back out into plain text. let { deleted, inserted } = run; const lead = commonEdge(deleted, inserted, "start"); const trail = commonEdge(deleted.slice(lead.length), inserted.slice(lead.length), "end"); deleted = deleted.slice(lead.length, deleted.length - trail.length); inserted = inserted.slice(lead.length, inserted.length - trail.length); if (lead) segments.push({ kind: "equal", text: lead }); const id = `${idPrefix}${changes.length + 1}`; if (deleted) segments.push({ kind: "delete", text: deleted, changeId: id }); if (inserted) segments.push({ kind: "insert", text: inserted, changeId: id }); if (deleted || inserted) changes.push({ id, kind: deleted && inserted ? "replace" : deleted ? "delete" : "insert", deleted, inserted }); if (trail) segments.push({ kind: "equal", text: trail }); ins += words(inserted); del += words(deleted); } return { segments: mergeEquals(segments), changes, stats: { inserted: ins, deleted: del, changes: changes.length } }; } const segmenters = new Map(); function diffByWords(before: string, after: string, locale?: string): ChangeObject[] { if (typeof Intl === "undefined" || typeof Intl.Segmenter !== "function") return diffWordsWithSpace(before, after); const key = locale ?? ""; let seg = segmenters.get(key); if (!seg) segmenters.set(key, (seg = new Intl.Segmenter(locale, { granularity: "word" }))); return diffWords(before, after, { intlSegmenter: seg }); } function commonEdge(a: string, b: string, edge: "start" | "end"): string { let n = 0; const max = Math.min(a.length, b.length); if (edge === "start") { while (n < max && a[n] === b[n] && /\s/.test(a[n])) n++; return a.slice(0, n); } while (n < max && a[a.length - 1 - n] === b[b.length - 1 - n] && /\s/.test(a[a.length - 1 - n])) n++; return n ? a.slice(a.length - n) : ""; } function mergeEquals(segments: RedlineSegment[]) { const out: RedlineSegment[] = []; for (const s of segments) { const last = out[out.length - 1]; if (last && last.kind === "equal" && s.kind === "equal") last.text += s.text; else if (s.text) out.push({ ...s }); } return out; } export type Decision = "accept" | "reject"; /** * The text after deciding each change: accepted changes take their insert, rejected ones * keep the original. Undecided changes follow `pending` (default `reject`: the original stands). */ export function resolveRedline(segments: readonly RedlineSegment[], decisions: Record, { pending = "reject" }: { pending?: Decision } = {}): string { let out = ""; for (const s of segments) { if (s.kind === "equal") out += s.text; else { const d = (s.changeId && decisions[s.changeId]) || pending; if ((s.kind === "insert" && d === "accept") || (s.kind === "delete" && d === "reject")) out += s.text; } } return out; } export type BlockDiff = { id: string; status: "same" | "changed" | "added" | "removed"; before?: DocBlock; after?: DocBlock; /** For changed blocks (and added/removed ones, as one insert/delete). */ redline: Redline; }; /** * Two versions of a document compared block by block (matched by id): the order of `after`, * with removed blocks kept where they were. Change ids are prefixed by block id, so they are * unique across the document. */ export function diffDocs(before: Doc, after: Doc, options: Omit = {}) { const old = new Map(before.blocks.map((b, i) => [b.id, { b, i }])); const kept = new Set(after.blocks.map((b) => b.id)); const out: BlockDiff[] = []; const emitRemovedBefore = (limit: number, from: { i: number }) => { for (; from.i < limit; from.i++) { const b = before.blocks[from.i]; if (!kept.has(b.id)) out.push({ id: b.id, status: "removed", before: b, redline: redline(b.text, "", { ...options, idPrefix: `${b.id}:` }) }); } }; const cursor = { i: 0 }; for (const b of after.blocks) { const prev = old.get(b.id); if (prev) emitRemovedBefore(prev.i, cursor); if (prev && cursor.i <= prev.i) cursor.i = prev.i + 1; const r = redline(prev?.b.text ?? "", b.text, { ...options, idPrefix: `${b.id}:` }); out.push({ id: b.id, status: !prev ? "added" : r.changes.length || prev.b.title !== b.title ? "changed" : "same", before: prev?.b, after: b, redline: r }); } emitRemovedBefore(before.blocks.length, cursor); const stats = out.reduce((s, d) => ({ inserted: s.inserted + d.redline.stats.inserted, deleted: s.deleted + d.redline.stats.deleted, changes: s.changes + d.redline.stats.changes }), { inserted: 0, deleted: 0, changes: 0, }); return { blocks: out, stats, changed: out.filter((d) => d.status !== "same").length }; } /** * Line hunks between two texts, shaped exactly like code-core's `DiffHunk` (`oldStart`, * `oldLines`, `newStart`, `newLines`, `lines: { kind, text }[]`), so a Diff Block can render a * document version diff without doc-core depending on code-core. */ export function lineHunks(before: string, after: string, { context = 3 }: { context?: number } = {}) { const patch = structuredPatch("before", "after", before, after, undefined, undefined, { context }); return patch.hunks.map((h) => ({ oldStart: h.oldStart, oldLines: h.oldLines, newStart: h.newStart, newLines: h.newLines, lines: h.lines .filter((l) => !l.startsWith("\\")) .map((l) => ({ kind: l[0] === "+" ? ("add" as const) : l[0] === "-" ? ("remove" as const) : ("context" as const), text: l.slice(1) })), })); } 65:Tb9a,export type DocBlockKind = "heading" | "paragraph" | "clause"; export type Risk = "low" | "medium" | "high"; /** One block of a document. Offsets in anchors and redlines are into `text`. */ export type DocBlock = { /** Stable across versions: `diffDocs` matches blocks by it. */ id: string; kind: DocBlockKind; text: string; /** Clause number, "4.2" (see `numberClauses`). */ number?: string; /** A clause's caption, "Limitation of liability". */ title?: string; /** Heading level (1–3) or clause depth (1 = "4", 2 = "4.2", 3 = "4.2.1"). Default 1. */ level?: number; risk?: Risk; }; export type Doc = { id: string; title: string; version?: string; blocks: DocBlock[] }; /** Assigns "1", "1.1", "1.1.1" … to clauses by `level`, restarting sub-numbers under each parent. Headings and paragraphs are skipped. Immutable. */ export function numberClauses(blocks: readonly DocBlock[]): DocBlock[] { const counters: number[] = []; return blocks.map((b) => { if (b.kind !== "clause") return b; const level = Math.max(1, b.level ?? 1); counters.length = level; for (let i = 0; i < level; i++) counters[i] ??= 0; counters[level - 1]++; return { ...b, number: counters.slice(0, level).join(".") }; }); } /** * A document from plain text: `# Title` and `## Heading` lines, numbered clauses ("4.", "4.2", * "4.2.1" with an optional "Title." caption), and blank-line paragraphs. Ids are `b1`, `b2` … * in order, so parse two versions with matching structure and they diff block by block. */ export function docFromText(text: string, { id = "doc" }: { id?: string } = {}): Doc { let title = ""; const blocks: DocBlock[] = []; let n = 0; for (const chunk of text.replace(/\r\n?/g, "\n").split(/\n\s*\n/)) { const raw = chunk.trim(); if (!raw) continue; const heading = /^(#{1,3})\s+([\s\S]*)$/.exec(raw); if (heading) { if (heading[1].length === 1 && !title) { title = heading[2].trim(); continue; } blocks.push({ id: `b${++n}`, kind: "heading", level: heading[1].length - 1 || 1, text: heading[2].trim() }); continue; } const clause = /^(\d+(?:\.\d+)*)\.?\s+(?:([A-Z][A-Za-z'’\- ]{1,48})\.\s+)?([\s\S]*)$/.exec(raw); if (clause) { // A caption is short ("Limitation of liability."); a longer first sentence is body text. const caption = clause[2] && clause[2].trim().split(/\s+/).length <= 6 ? clause[2].trim() : undefined; const body = caption ? clause[3] : raw.slice(clause[1].length).replace(/^\.?\s+/, ""); blocks.push({ id: `b${++n}`, kind: "clause", number: clause[1], level: clause[1].split(".").length, title: caption, text: body.replace(/\s*\n\s*/g, " ").trim() }); continue; } blocks.push({ id: `b${++n}`, kind: "paragraph", text: raw.replace(/\s*\n\s*/g, " ") }); } return { id, title, blocks }; } export const blockById = (doc: Doc, id: string) => doc.blocks.find((b) => b.id === id); 60:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","diff",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/diff","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"diff"}]]}]}]]}],["$","$L61",null,{"namespace":"@registrydirectory","registryDependencies":["https://eased.dev/r/eased-tokens.json"]}]]}],null]}],["$","$L62",null,{"files":[{"path":"src/registry/eased/_primitives/doc-core/anchors.ts","content":"$63","type":"registry:lib","target":"@components/eased/_primitives/doc-core/anchors.ts"},{"path":"src/registry/eased/_primitives/doc-core/doc-core.ts","content":"/**\n * doc-core: documents for contract review and docs. A paragraph/clause model, inline redlines\n * (insert/delete, grouped into accept-or-reject changes) on the `diff` package, block-level\n * version diffs, and durable anchors for comments and AI suggestions.\n * Import from here; the files behind it may move.\n */\nexport { blockById, docFromText, numberClauses, type Doc, type DocBlock, type DocBlockKind, type Risk } from \"./types\";\nexport {\n diffDocs,\n lineHunks,\n redline,\n resolveRedline,\n type BlockDiff,\n type Decision,\n type Redline,\n type RedlineChange,\n type RedlineOptions,\n type RedlineSegment,\n} from \"./redline\";\nexport {\n anchorFromSelection,\n anchorQuote,\n applySuggestion,\n createAnchor,\n mapOffset,\n rebaseAnchor,\n resolveAnchor,\n splitByAnchors,\n suggestionPreview,\n type Comment,\n type MarkedRun,\n type ResolvedAnchor,\n type Suggestion,\n type TextAnchor,\n} from \"./anchors\";\n","type":"registry:lib","target":"@components/eased/_primitives/doc-core/doc-core.ts"},{"path":"src/registry/eased/_primitives/doc-core/redline.ts","content":"$64","type":"registry:lib","target":"@components/eased/_primitives/doc-core/redline.ts"},{"path":"src/registry/eased/_primitives/doc-core/types.ts","content":"$65","type":"registry:lib","target":"@components/eased/_primitives/doc-core/types.ts"}],"className":"h-[70svh] min-h-80"}]]}]