{"version":3,"file":"y.cjs","names":[],"sources":["../src/y/extensions/YAttributionMarks.ts","../src/y/extensions/AttributionExtension.ts","../src/y/extensions/RelativePositionMapping.ts","../src/y/extensions/blockMatchNodes.ts","../src/y/extensions/YSync.ts","../src/y/utils.ts","../src/y/extensions/Suggestions.ts","../src/y/extensions/Versioning.ts","../src/y/extensions/YCursorPlugin.ts","../src/y/extensions/DiffVersioningExtension.ts","../src/y/extensions/index.ts","../src/y/comments/yjsHelpers.ts","../src/y/comments/YjsThreadStoreBase.ts","../src/y/comments/RESTYjsThreadStore.ts","../src/y/comments/YjsThreadStore.ts","../src/y/versioning/yhub.ts"],"sourcesContent":["import { Mark } from \"@tiptap/core\";\nimport { Mark as PMMark, MarkSpec } from \"prosemirror-model\";\nimport {\n createExtension,\n type ExtensionOptions,\n} from \"../../editor/BlockNoteExtension.js\";\nimport type { BlockNoteEditor } from \"../../editor/BlockNoteEditor.js\";\nimport { BLOCK_LEVEL_SUGGESTION_GROUP } from \"../../pm-nodes/suggestionMarks.js\";\nimport { NON_FORMATTING_MARK_GROUP } from \"../../schema/markGroups.js\";\nimport {\n fallbackColorForUserId,\n userColorPalette,\n userColorVarNames,\n} from \"../../user/index.js\";\n\n/**\n * Describes a suggestion mark to {@link GetAttributionMarkClassName}: whether it\n * wraps inline content or a whole block, and which kind of change it represents.\n * `modificationType: \"format\"` corresponds to the `y-attributed-format`\n * (modification) mark.\n */\nexport type AttributionMarkStyleInfo = {\n contentType: \"inline-content\" | \"block\";\n modificationType: \"insert\" | \"delete\" | \"format\";\n};\n\n/**\n * The class name(s) an app returns to style a suggestion mark. Either:\n * - a single string applied to *both* the mark content and its hover tooltip, or\n * - `{ content, tooltip }` to style the mark content and the tooltip\n * independently.\n */\nexport type AttributionMarkClassNames =\n | string\n | { content: string; tooltip: string };\n\n/**\n * Optional callback to override suggestion-mark styling. Given a mark's\n * {@link AttributionMarkStyleInfo}, it returns the class name(s) to apply (see\n * {@link AttributionMarkClassNames}). When a class is returned, the default\n * per-user color (the `--user-color-*` custom properties and the built-in\n * `.bn-suggestion-mark` / `.bn-suggestion-node` styling) is *not* applied to the\n * mark content, so the class fully controls its appearance — letting an app\n * color suggestions by change type (e.g. green insertions, red deletions)\n * instead of by author.\n */\nexport type GetAttributionMarkClassName = (\n info: AttributionMarkStyleInfo,\n) => AttributionMarkClassNames;\n\n/**\n * Resolve the {@link AttributionMarkClassNames} returned by a\n * {@link GetAttributionMarkClassName} callback to the class name for a single\n * target (the mark `content` or its `tooltip`).\n */\nexport const resolveAttributionMarkClassName = (\n result: AttributionMarkClassNames | undefined,\n target: \"content\" | \"tooltip\",\n): string | undefined =>\n result === undefined\n ? undefined\n : typeof result === \"string\"\n ? result\n : result[target];\n\n/**\n * Shared mark view for the attribution marks (insert / delete / modification).\n * It renders the marked content and tags the wrapper with the author(s) via\n * `data-*` attributes. The attribution tooltip shown on hover is handled\n * separately by the `AttributionExtension`, which reads those attributes\n * straight from the DOM — keeping this mark view purely presentational and the\n * tooltip state off of module scope.\n *\n * Author colors are *not* baked into the (deterministic) mark attrs. Instead the\n * wrapper sets the generic `--user-color-*` custom properties the Block.css rules\n * read, sourcing them from the author's *per-user* CSS variable via\n * `var(--user-color--*, )`. Those per-user variables are populated\n * on the editor root by `AttributionExtension` once the user resolves, so a mark\n * shows the deterministic palette fallback immediately and recolors to the\n * author's own color purely through the CSS cascade — no decoration, no doc\n * transaction. See `userColors.ts`.\n */\nconst createAttributionMarkView =\n (\n type: \"insert\" | \"delete\" | \"modification\",\n options?: {\n editor?: BlockNoteEditor;\n getAttributionMarkClassName?: GetAttributionMarkClassName;\n },\n ) =>\n ({ mark, inline }: { mark: PMMark; inline: boolean }) => {\n const editor = options?.editor;\n // ``/`` are semantic elements. The modification mark has no\n // dedicated element, so it renders as a `` inline or a `
` over a\n // block, matching its `parseDOM` rules.\n const tag =\n type === \"insert\"\n ? \"ins\"\n : type === \"delete\"\n ? \"del\"\n : inline\n ? \"span\"\n : \"div\";\n const dom = document.createElement(tag);\n\n Object.assign(dom.dataset, {\n userIds: JSON.stringify(mark.attrs[\"userIds\"]),\n inline: String(inline),\n });\n if (type === \"modification\") {\n dom.dataset[\"type\"] = \"modification\";\n dom.dataset[\"format\"] = JSON.stringify(mark.attrs[\"format\"]);\n }\n\n // Optional app-provided override: `y-attributed-format` is exposed as\n // `\"format\"`. When a class is returned it's applied to the content element\n // *instead of* the built-in `.bn-suggestion-mark` / `.bn-suggestion-node`\n // classes, and the per-user `--user-color-*` properties are omitted, so the\n // class fully controls the appearance (background, text color, etc.) with no\n // per-user color leaking through (see the type doc).\n const contentClassName = resolveAttributionMarkClassName(\n options?.getAttributionMarkClassName?.({\n contentType: inline ? \"inline-content\" : \"block\",\n modificationType: type === \"modification\" ? \"format\" : type,\n }),\n \"content\",\n );\n\n // The wrapper is always `display: contents` so it never generates a box of\n // its own — an inline ``/`` around block/table content (e.g. a\n // suggestion spanning table cells) would otherwise break the normal layout.\n // Because a `display: contents` element paints nothing, the highlight is\n // applied to the inner content span (see `.bn-suggestion-mark` in Block.css)\n // using the `--user-color-*` custom properties, which cascade down from here.\n // They're sourced from the author's per-user variable (populated on the\n // editor root by `AttributionExtension`) with the deterministic palette as a\n // fallback, so a mark is colored before the user resolves and recolors via\n // the cascade afterward. When an override class owns the styling, no per-user\n // color is applied at all.\n const userIds = (mark.attrs[\"userIds\"] as string[] | null) ?? [];\n const firstId = userIds[0];\n const fallback = firstId\n ? fallbackColorForUserId(firstId)\n : userColorPalette[0];\n if (contentClassName) {\n dom.style.cssText = \"display: contents\";\n } else {\n const light = firstId\n ? `var(${userColorVarNames(firstId).light}, ${fallback.light})`\n : fallback.light;\n const dark = firstId\n ? `var(${userColorVarNames(firstId).dark}, ${fallback.dark})`\n : fallback.dark;\n dom.style.cssText =\n \"display: contents\" +\n `; --user-color-light: ${light}; --user-color-dark: ${dark}`;\n }\n\n const contentDOM = document.createElement(\"span\");\n if (inline) {\n // Inline content: the span is a real inline box that carries the highlight\n // (default path) or the app-provided override class.\n contentDOM.className =\n contentClassName ??\n (type === \"delete\"\n ? \"bn-suggestion-mark bn-suggestion-mark--delete\"\n : \"bn-suggestion-mark\");\n } else {\n // Block-level marks wrap block/table structure (e.g. //

). The\n // span must be `display: contents` so it doesn't inject an inline box into\n // the table layout (which triggers the browser's anonymous-table fixup and\n // breaks the table). Such a span has no box to paint a background on, so\n // the `.bn-suggestion-node` rule highlights its children (the wrapped\n // nodes) instead. An override class is applied to the same span, so it\n // should likewise target its children (e.g. `.my-class > *`).\n contentDOM.style.display = \"contents\";\n contentDOM.className =\n contentClassName ??\n (type === \"delete\"\n ? \"bn-suggestion-node bn-suggestion-node--delete\"\n : \"bn-suggestion-node\");\n if (type === \"delete\") {\n // A deleted block shows a localized \"Deleted\" badge via a `::before`\n // (see Block.css). The badge text is passed down as a CSS string token\n // in `--deleted-label` so the stylesheet stays locale-agnostic; the\n // wrapper is `display: contents` and can't paint a pseudo-element of its\n // own, so the rule renders the badge on the wrapped node instead, which\n // inherits this custom property.\n const label = editor?.dictionary.suggestion_changes.deleted;\n if (label) {\n contentDOM.style.setProperty(\n \"--deleted-label\",\n JSON.stringify(label),\n );\n }\n }\n }\n dom.appendChild(contentDOM);\n\n return {\n dom,\n contentDOM,\n };\n };\n\nexport const YAttributedInsertion = Mark.create<{\n getAttributionMarkClassName?: GetAttributionMarkClassName;\n}>({\n name: \"y-attributed-insert\",\n inclusive: false,\n excludes: \"\",\n // Two groups: `BLOCK_LEVEL_SUGGESTION_GROUP` lets the mark sit on block nodes\n // (see `suggestionMarks`), so a whole block can be marked as inserted in\n // suggestion mode; `NON_FORMATTING_MARK_GROUP` lets it annotate text inside\n // `\"plain\"` blocks (e.g. code blocks) — see `nonFormattingMarks`.\n group: `${BLOCK_LEVEL_SUGGESTION_GROUP} ${NON_FORMATTING_MARK_GROUP}`,\n addAttributes() {\n return {\n userIds: { default: null },\n };\n },\n addMarkView() {\n return createAttributionMarkView(\"insert\", {\n getAttributionMarkClassName: this.options.getAttributionMarkClassName,\n });\n },\n extendMarkSchema(extension) {\n if (extension.name !== this.name) {\n return {};\n }\n return {\n blocknoteIgnore: true,\n } satisfies MarkSpec;\n },\n});\n\nexport const YAttributedDeletion = Mark.create<{\n editor?: BlockNoteEditor;\n getAttributionMarkClassName?: GetAttributionMarkClassName;\n}>({\n name: \"y-attributed-delete\",\n inclusive: false,\n excludes: \"\",\n group: `${BLOCK_LEVEL_SUGGESTION_GROUP} ${NON_FORMATTING_MARK_GROUP}`,\n addAttributes() {\n return {\n userIds: { default: null },\n };\n },\n addMarkView() {\n return createAttributionMarkView(\"delete\", {\n editor: this.options.editor,\n getAttributionMarkClassName: this.options.getAttributionMarkClassName,\n });\n },\n extendMarkSchema(extension) {\n if (extension.name !== this.name) {\n return {};\n }\n return {\n blocknoteIgnore: true,\n } satisfies MarkSpec;\n },\n});\n\nexport const YAttributedFormat = Mark.create<{\n getAttributionMarkClassName?: GetAttributionMarkClassName;\n}>({\n name: \"y-attributed-format\",\n inclusive: false,\n excludes: \"\",\n group: `${BLOCK_LEVEL_SUGGESTION_GROUP} ${NON_FORMATTING_MARK_GROUP}`,\n addAttributes() {\n return {\n userIds: { default: null },\n format: { default: null },\n };\n },\n addMarkView() {\n return createAttributionMarkView(\"modification\", {\n getAttributionMarkClassName: this.options.getAttributionMarkClassName,\n });\n },\n extendMarkSchema(extension) {\n if (extension.name !== this.name) {\n return {};\n }\n return {\n blocknoteIgnore: true,\n } satisfies MarkSpec;\n },\n});\n\n/**\n * Bundles the three `y-attributed-*` suggestion marks into a single BlockNote\n * extension, so they can be registered wherever they're actually needed (the\n * Yjs collaboration extension, or a test that exercises suggestions) instead of\n * living in the default schema. The marks opt into being allowed on block nodes\n * via their `blockLevelSuggestion` option — see `suggestionMarks`.\n */\nexport const YAttributionMarksExtension = createExtension(\n ({\n options,\n }: ExtensionOptions<\n { getAttributionMarkClassName?: GetAttributionMarkClassName } | undefined\n >) => ({\n key: \"yAttributionMarks\",\n tiptapExtensions: [\n YAttributedInsertion.configure({\n getAttributionMarkClassName: options?.getAttributionMarkClassName,\n }),\n YAttributedDeletion.configure({\n getAttributionMarkClassName: options?.getAttributionMarkClassName,\n }),\n YAttributedFormat.configure({\n getAttributionMarkClassName: options?.getAttributionMarkClassName,\n }),\n ],\n }),\n);\n","import { getChangedRanges } from \"@tiptap/core\";\nimport { Plugin, PluginKey, type Transaction } from \"prosemirror-state\";\nimport {\n createExtension,\n createStore,\n type ExtensionOptions,\n} from \"../../editor/BlockNoteExtension.js\";\nimport {\n colorsForUserIds,\n userColorVarNames,\n normalizeToUserStore,\n type UserStoreOrResolver,\n} from \"../../user/index.js\";\nimport {\n resolveAttributionMarkClassName,\n YAttributionMarksExtension,\n type GetAttributionMarkClassName,\n} from \"./YAttributionMarks.js\";\n\n/** The attribution marks, mapped to their `modificationType`. */\nconst ATTRIBUTION_MARK_TYPES = {\n \"y-attributed-insert\": \"insert\",\n \"y-attributed-delete\": \"delete\",\n \"y-attributed-format\": \"format\",\n} as const;\n\nconst ATTRIBUTION_LOAD_PLUGIN_KEY = new PluginKey(\"attributionLoadUsers\");\n\n/** Wrapper of an attribution mark; carries its author(s) in `data-user-ids`. */\nconst ATTRIBUTION_MARK_SELECTOR = \"[data-user-ids]\";\n\n/** Parse the JSON-encoded `data-user-ids` attribute; `[]` if missing/malformed. */\nconst parseUserIds = (userIdsJSON: string | undefined): string[] => {\n if (!userIdsJSON) {\n return [];\n }\n let userIds: unknown;\n try {\n userIds = JSON.parse(userIdsJSON);\n } catch {\n return [];\n }\n return Array.isArray(userIds) ? userIds.map(String) : [];\n};\n\n/**\n * The changed format keys from a modification mark's `data-format` (e.g.\n * `[\"bold\", \"italic\"]`); `[]` if missing/malformed or an empty change. This is\n * the raw change context — turning it into a localized label (e.g.\n * `\"Bold, Italic\"`) is a view concern owned by the React layer's\n * `formatChangeLabel`, so core stays i18n-agnostic here.\n */\nconst parseFormatKeys = (formatJSON: string | undefined): string[] => {\n if (!formatJSON) {\n return [];\n }\n let format: unknown;\n try {\n format = JSON.parse(formatJSON);\n } catch {\n return [];\n }\n if (typeof format !== \"object\" || format === null) {\n return [];\n }\n return Object.keys(format);\n};\n\n/**\n * The element with a real box to anchor the tooltip to. The wrapper is\n * `display: contents` (no box of its own), so use its content span child,\n * falling back further for block marks.\n */\nconst getReferenceElement = (wrapper: Element): Element => {\n const content = wrapper.firstElementChild ?? wrapper;\n const rect = content.getBoundingClientRect();\n if (rect.width || rect.height) {\n return content;\n }\n return content.firstElementChild ?? content;\n};\n\n/**\n * The box the tooltip anchors to. The wrapper is `display: contents` (no box of\n * its own), so use its content span child, falling back further for block marks.\n * Exported for the React controller's floating-ui `getBoundingClientRect`.\n */\nexport const getReferenceRect = (wrapper: Element): DOMRect =>\n getReferenceElement(wrapper).getBoundingClientRect();\n\n/**\n * The per-line client rects of the reference element, for floating-ui's\n * `inline()` middleware — it needs one rect per line to position off a\n * multi-line mark, and virtual elements don't get a default `getClientRects`.\n */\nexport const getReferenceClientRects = (wrapper: Element): DOMRectList =>\n getReferenceElement(wrapper).getClientRects();\n\n/**\n * State for the currently-hovered suggestion mark's tooltip (`undefined` when\n * none). The extension computes it; a React controller renders + positions it\n * (see `AttributionTooltipController`).\n */\nexport type AttributionTooltipState = {\n /** The wrapper element the tooltip anchors to (floating-ui reference). */\n anchor: HTMLElement;\n /** Per-user background color, resolved from the user store (default path). */\n color: string;\n /** The kind of change — `format` is the modification mark. */\n modificationType: \"insert\" | \"delete\" | \"format\";\n /** Whether the mark wraps inline content or a whole block. */\n contentType: \"inline-content\" | \"block\";\n /** Resolved usernames (falls back to raw ids), for custom renderers. */\n users: string[];\n /**\n * The changed format keys (e.g. `[\"bold\", \"italic\"]`), present only for\n * `format` marks. This is the raw change context — the view layer turns it\n * into a localized label via its `formatChangeLabel`.\n */\n format?: string[];\n /**\n * Class name from the `getAttributionMarkClassName` callback (override path).\n * When present, the tooltip applies this and skips the inline `color`.\n */\n className?: string;\n};\n\n/**\n * Resolves the attribution tooltip state for suggestion marks on hover (exposed\n * via a store for React), and loads each mark's author so its color/username\n * resolves. Marks nest, so a single delegated `mouseover` listener picks the\n * `closest` wrapper to the pointer — the innermost mark wins.\n */\nexport const AttributionExtension = createExtension(\n ({\n options,\n }: ExtensionOptions<\n | {\n /** Resolves authors to usernames. Optional; unresolved ids show raw. */\n resolveUsers?: UserStoreOrResolver;\n /** See {@link GetAttributionMarkClassName}. */\n getAttributionMarkClassName?: GetAttributionMarkClassName;\n }\n | undefined\n >) => {\n const userStore = normalizeToUserStore(options?.resolveUsers);\n const getAttributionMarkClassName = options?.getAttributionMarkClassName;\n\n const store = createStore(undefined);\n\n // Load the authors of the attribution marks in `tr`'s changed ranges, so\n // their colors/usernames resolve (colors then flow to marks via `syncRootVars`).\n // `getChangedRanges` covers mark-only steps too — which suggestion mode adds\n // over existing text and `tr.changedRange()` would miss.\n const loadChangedUsers = (tr: Transaction) => {\n const ranges = getChangedRanges(tr);\n if (ranges.length === 0) {\n return;\n }\n // Most changes are local (often several steps in one small span), so scan a\n // single range spanning all of them rather than each range individually.\n let from = Infinity;\n let to = -Infinity;\n for (const { newRange } of ranges) {\n from = Math.min(from, newRange.from);\n to = Math.max(to, newRange.to);\n }\n\n const ids = new Set();\n tr.doc.nodesBetween(from, to, (node) => {\n for (const mark of node.marks) {\n if (\n ATTRIBUTION_MARK_TYPES[\n mark.type.name as keyof typeof ATTRIBUTION_MARK_TYPES\n ]\n ) {\n const userIds = mark.attrs[\"userIds\"] as string[] | null;\n userIds?.forEach((id) => ids.add(id));\n }\n }\n return true;\n });\n if (ids.size > 0) {\n void userStore.loadUsers(Array.from(ids));\n }\n };\n\n return {\n key: \"attribution\",\n userStore,\n store,\n prosemirrorPlugins: [\n // Marks arrive in a transaction (suggestion mode, viewing suggestions,\n // version preview), so resolve their authors as the doc changes.\n new Plugin({\n key: ATTRIBUTION_LOAD_PLUGIN_KEY,\n state: {\n init: () => null,\n apply: (tr) => {\n if (tr.docChanged) {\n loadChangedUsers(tr);\n }\n return null;\n },\n },\n }),\n ],\n mount({ dom, root, signal }) {\n // Write each resolved author's color to the editor root as per-user CSS\n // variables (`--user-color--{light,dark}`) that the mark wrappers read\n // via `var(..., )`, so the cascade recolors marks once a color\n // resolves. Color-less users have theirs removed so the fallback applies.\n const syncRootVars = () => {\n for (const [id, user] of userStore.store.state) {\n const { light, dark } = userColorVarNames(id);\n if (user.color && user.colorLight) {\n dom.style.setProperty(light, user.colorLight);\n dom.style.setProperty(dark, user.color);\n } else {\n dom.style.removeProperty(light);\n dom.style.removeProperty(dark);\n }\n }\n };\n\n // The wrapper currently showing a tooltip, so we don't re-emit on every\n // `mouseover` over the same mark.\n let activeAnchor: HTMLElement | undefined;\n\n // The mark's authors as usernames, falling back to the raw id when not\n // cached (`getUser` is cache-only; ids load on hover, see `onPointerOver`).\n const usersLabelArray = (userIdsJSON: string | undefined): string[] =>\n parseUserIds(userIdsJSON).map(\n (id) => userStore.getUser(id)?.username ?? id,\n );\n\n // A stable identity string for a wrapper (empty if unattributed), used to\n // (a) test whether a mark is attributed and (b) group adjacent marks with\n // the *same* attribution under one tooltip. It's an internal grouping key,\n // not the displayed text — that's composed in the view from `users` and\n // the format label — so it's built from raw `data-*` (ids + format keys)\n // and stays free of i18n/username resolution.\n const attributionIdentity = (wrapper: HTMLElement) => {\n const ids = parseUserIds(wrapper.dataset[\"userIds\"]);\n if (ids.length === 0) {\n return \"\";\n }\n const format = parseFormatKeys(wrapper.dataset[\"format\"]);\n return `${format.join(\",\")}:${ids.join(\",\")}`;\n };\n\n // Build the tooltip state from a wrapper's `data-*` attributes.\n const buildState = (anchor: HTMLElement): AttributionTooltipState => {\n const isModification = anchor.dataset[\"format\"] !== undefined;\n const modificationType: AttributionTooltipState[\"modificationType\"] =\n isModification\n ? \"format\"\n : anchor.tagName === \"INS\"\n ? \"insert\"\n : \"delete\";\n const contentType: AttributionTooltipState[\"contentType\"] =\n anchor.dataset[\"inline\"] === \"false\" ? \"block\" : \"inline-content\";\n\n return {\n anchor,\n // The tooltip is portaled outside the editor root, so it can't read\n // the cascaded per-user vars — resolve a concrete color from the store.\n color: colorsForUserIds(\n userStore,\n parseUserIds(anchor.dataset[\"userIds\"]),\n ).dark,\n modificationType,\n contentType,\n users: usersLabelArray(anchor.dataset[\"userIds\"]),\n format: isModification\n ? parseFormatKeys(anchor.dataset[\"format\"])\n : undefined,\n className: resolveAttributionMarkClassName(\n getAttributionMarkClassName?.({ contentType, modificationType }),\n \"tooltip\",\n ),\n };\n };\n\n const hideTooltip = () => {\n if (!activeAnchor) {\n return;\n }\n activeAnchor = undefined;\n store.setState(undefined);\n };\n\n // The innermost attributed mark at or above `el`, skipping unattributed\n // wrappers so an attributed ancestor still wins.\n const innermostAttributed = (\n el: Element | null,\n ): HTMLElement | undefined => {\n while (el) {\n const wrapper = el.closest(ATTRIBUTION_MARK_SELECTOR);\n if (!wrapper) {\n return undefined;\n }\n if (attributionIdentity(wrapper)) {\n return wrapper;\n }\n el = wrapper.parentElement;\n }\n return undefined;\n };\n\n const onPointerOver = (event: Event) => {\n const target = event.target instanceof Element ? event.target : null;\n const innermost = innermostAttributed(target);\n if (!innermost) {\n // Not over an attributed mark — drop the current tooltip.\n hideTooltip();\n return;\n }\n\n const identity = attributionIdentity(innermost);\n // Anchor on the outermost ancestor with the *same* attribution so one\n // tooltip covers the whole region; a differently-attributed ancestor\n // breaks the chain, and unattributed ones are climbed past.\n let anchor = innermost;\n let el: Element | null = innermost.parentElement;\n while (el) {\n const ancestor = el.closest(ATTRIBUTION_MARK_SELECTOR);\n if (!ancestor) {\n break;\n }\n const ancestorIdentity = attributionIdentity(ancestor);\n if (ancestorIdentity === identity) {\n anchor = ancestor;\n } else if (ancestorIdentity) {\n break;\n }\n el = ancestor.parentElement;\n }\n\n if (activeAnchor === anchor) {\n return;\n }\n\n activeAnchor = anchor;\n store.setState(buildState(anchor));\n\n // First hover renders raw ids (cache-only); load the authors and refresh\n // the resolved usernames once loaded, if this mark is still active.\n const ids = parseUserIds(anchor.dataset[\"userIds\"]);\n if (ids.length > 0) {\n void userStore.loadUsers(ids).then(() => {\n if (activeAnchor !== anchor) {\n return;\n }\n store.setState(buildState(anchor));\n });\n }\n };\n\n root.addEventListener(\"mouseover\", onPointerOver, { signal });\n signal.addEventListener(\"abort\", hideTooltip);\n\n // Seed from the cache, then keep the vars in sync as users resolve.\n syncRootVars();\n const unsubscribe = userStore.store.subscribe(syncRootVars);\n signal.addEventListener(\"abort\", unsubscribe);\n },\n\n // The `y-attributed-*` marks aren't in the default schema — register them\n // here so the block specs can allow them (collaboration-only).\n blockNoteExtensions: [\n YAttributionMarksExtension({\n getAttributionMarkClassName: options?.getAttributionMarkClassName,\n }),\n ],\n };\n },\n);\n","import { relativePositionStore, ySyncPluginKey } from \"@y/prosemirror\";\nimport { createExtension } from \"../../editor/BlockNoteExtension.js\";\n\nexport const RelativePositionMappingExtension = createExtension(\n ({ editor }) => {\n return {\n key: \"yPositionMapping\",\n mapPosition: (position: number, side: \"left\" | \"right\" = \"left\") => {\n const ySyncPluginState = ySyncPluginKey.getState(\n editor.prosemirrorState,\n );\n if (!ySyncPluginState?.ytype) {\n throw new Error(\"YSync plugin state not found\");\n }\n\n // 0 is a special case & always should map to itself\n if (position === 0) {\n return () => 0;\n }\n\n const posStore = relativePositionStore(\n editor.prosemirrorState.doc.resolve(\n position + (side === \"right\" ? 1 : -1),\n ),\n ySyncPluginState.ytype,\n ySyncPluginState.renderer,\n );\n\n return () => {\n const curYSyncPluginState = ySyncPluginKey.getState(\n editor.prosemirrorState,\n ) as typeof ySyncPluginState;\n const pos = posStore(\n editor.prosemirrorState.doc,\n curYSyncPluginState.ytype,\n curYSyncPluginState.renderer,\n );\n\n // This can happen if the element is garbage collected\n if (pos === null) {\n throw new Error(\"Position not found, cannot track positions\");\n }\n\n return pos + (side === \"right\" ? -1 : 1);\n };\n },\n } as const;\n },\n);\n","import { $prosemirrorDelta } from \"@y/prosemirror\";\nimport * as delta from \"lib0/delta\";\nimport * as schema from \"lib0/schema\";\n\n/**\n * Canonical name of a content delta's first block child (the child carried by an\n * insert op), or `null`. For a BlockNote `blockContainer` (content\n * `blockContent blockGroup?`) this is its block-content type (paragraph,\n * heading, image, ...).\n */\nconst firstChild = (\n d: schema.Unwrap,\n): schema.Unwrap | null => {\n for (const op of (d as any).children) {\n if (delta.$insertOp.check(op)) {\n for (const it of op.insert) {\n if (delta.$deltaAny.check(it)) {\n return it;\n }\n }\n }\n }\n return null;\n};\n\n/**\n * Whether a `blockContainer` delta carries a child `blockGroup` — i.e. the block\n * has nested children. A container's content is `blockContent blockGroup?`, so\n * this is what tells a leaf block apart from a parent.\n */\nconst hasBlockGroup = (d: schema.Unwrap): boolean => {\n for (const op of (d as any).children) {\n if (delta.$insertOp.check(op)) {\n for (const it of op.insert) {\n if (delta.$deltaAny.check(it) && it.name === \"blockGroup\") {\n return true;\n }\n }\n }\n }\n return false;\n};\n\nfunction getTableDimensions(\n d: schema.Unwrap,\n): { rows: number; cols: number } | null {\n if (d.name !== \"table\") {\n return null;\n }\n\n // Collect all rows with their cells' colspan/rowspan values.\n const rows: Array> = [];\n for (const op of (d as any).children) {\n if (delta.$insertOp.check(op)) {\n for (const tr of op.insert as Array<\n schema.Unwrap\n >) {\n if (tr.name !== \"tableRow\") {\n return null;\n }\n const cells: Array<{ colspan: number; rowspan: number }> = [];\n for (const trOp of (tr as any).children) {\n if (delta.$insertOp.check(trOp)) {\n for (const td of trOp.insert as Array<\n schema.Unwrap\n >) {\n if (td.name !== \"tableCell\" && td.name !== \"tableHeader\") {\n return null;\n }\n cells.push({\n colspan: Number(td.attrs.colspan) || 1,\n rowspan: Number(td.attrs.rowspan) || 1,\n });\n }\n }\n }\n rows.push(cells);\n }\n }\n }\n\n if (rows.length === 0) {\n return null;\n }\n\n // Build an occupancy grid to determine the true column count.\n // Each entry in `grid[r]` tracks which columns are already occupied\n // (by a cell from a previous row with rowspan > 1).\n const grid: boolean[][] = [];\n for (let r = 0; r < rows.length; r++) {\n if (!grid[r]) {\n grid[r] = [];\n }\n let col = 0;\n for (const cell of rows[r]) {\n // Skip columns already occupied by a rowspan from above.\n while (grid[r][col]) {\n col++;\n }\n // Mark all slots this cell occupies.\n for (let dr = 0; dr < cell.rowspan; dr++) {\n if (!grid[r + dr]) {\n grid[r + dr] = [];\n }\n for (let dc = 0; dc < cell.colspan; dc++) {\n grid[r + dr][col + dc] = true;\n }\n }\n col += cell.colspan;\n }\n }\n\n const numCols = Math.max(...grid.map((row) => row.length));\n return { rows: rows.length, cols: numCols };\n}\n\n/**\n * BlockNote's node-pairing policy for y-prosemirror's `matchNodes` option\n * (forwarded to `lib0/delta.diff`). This is the schema-specific bit that lives\n * in userland - the binding itself stays schema-agnostic.\n *\n * A `blockContainer` holds exactly one block content (`blockContent\n * blockGroup?`). Diffing a *type change* of that content as an in-place child\n * delete+insert would, under a suggestion, tombstone the old content next to the\n * new one => two block-contents in one container => schema-invalid. So we\n * declare a container's identity to be its first block-content child's type:\n * when that changes, the two containers are reported as *different*, the PM->Y\n * diff replaces the whole container, and the deleted + inserted containers sit\n * as siblings in the blockGroup (`blockGroupChild+` allows that). Each carries\n * the `y-attributed-*` node mark - which `blockContainer` already whitelists -\n * so no schema change and no storage transform are needed. A plain text edit\n * keeps the same first-child type => same identity => the diff descends and\n * merges as usual.\n *\n * @param a removed (old) node\n * @param b inserted (new) node\n * @returns whether `a` and `b` are the same node (diff in place) vs different (replace)\n */\nexport const blockMatchNodes = (\n a: schema.Unwrap,\n b: schema.Unwrap,\n): boolean => {\n if (a.name !== b.name) {\n return false;\n }\n\n if (a.name !== \"blockContainer\") {\n return true;\n }\n\n const childA = firstChild(a);\n const childB = firstChild(b);\n\n if (childA?.name !== childB?.name) {\n return false;\n }\n\n // A change in nesting is structural too: if one container gains or loses a\n // child `blockGroup`, diffing it in place would insert/delete the blockGroup as\n // a sibling of the block content inside a single container — schema-invalid.\n // Treat it as different so the whole container is replaced instead, same as a\n // content-type change. Keeps concurrent nesting merges (e.g. two users nesting\n // a block under the same parent) from producing a lopsided in-place result.\n if (hasBlockGroup(a) !== hasBlockGroup(b)) {\n return false;\n }\n\n if (childA?.name === \"table\" && childB?.name === \"table\") {\n const dimA = getTableDimensions(childA);\n const dimB = getTableDimensions(childB);\n if (\n dimA !== null &&\n dimB !== null &&\n dimA.rows !== dimB.rows &&\n dimA.cols !== dimB.cols\n ) {\n return false;\n }\n }\n\n return true;\n};\n","import { configureYProsemirror, syncPlugin } from \"@y/prosemirror\";\nimport {\n type ExtensionOptions,\n createExtension,\n} from \"../../editor/BlockNoteExtension.js\";\nimport { blockMatchNodes } from \"./blockMatchNodes.js\";\nimport { CollaborationOptions } from \"./index.js\";\n\n/**\n * Maps a Y attribution to BlockNote's `y-attributed-*` mark attrs.\n *\n * The mapper must be deterministic in `(format, attribution)` and emit attrs\n * that exactly match the declared mark schema in YAttributionMarks.ts. Any\n * mismatch causes the sync plugin to fire phantom reconcile dispatches in a\n * loop. See ATTRIBUTION.md in @y/prosemirror.\n *\n * Crucially the marks carry only stable identity (`userIds`, plus `format` for\n * the modification mark) — *not* user colors. Colors resolve asynchronously\n * from the {@link UserStore}, so baking them in here would make the mapper's\n * output change under a fixed `(format, attribution)` once a user loads, which\n * is exactly the non-determinism that triggers the reconcile loop. Instead the\n * `AttributionExtension` applies colors as a decoration layer that can\n * update independently of the mark representation.\n */\nexport const mapAttributionToMark = (\n format: Record | null,\n attribution: {\n insert?: readonly string[];\n delete?: readonly string[];\n format?: Record;\n insertAt?: number;\n deleteAt?: number;\n formatAt?: number;\n },\n): Record => {\n const out: Record = { ...format };\n\n if (attribution.insert) {\n out[\"y-attributed-insert\"] = { userIds: attribution.insert };\n }\n\n if (attribution.delete) {\n out[\"y-attributed-delete\"] = { userIds: attribution.delete };\n }\n\n if (attribution.format) {\n const userIds = [...new Set(Object.values(attribution.format).flat())];\n out[\"y-attributed-format\"] = { userIds, format: attribution.format };\n }\n\n return out;\n};\n\nexport const YSyncExtension = createExtension(\n ({\n options,\n editor,\n }: ExtensionOptions<\n Pick<\n CollaborationOptions,\n | \"fragment\"\n | \"renderer\"\n | \"suggestionDoc\"\n | \"provider\"\n | \"getAttributionMarkClassName\"\n >\n >) => {\n return {\n key: \"ySync\",\n fragment: options.fragment,\n mount: () => {\n const configure = () => {\n editor.exec(\n configureYProsemirror({\n ytype: options.fragment,\n // purposefully not passing `renderer` here, this is only for syncing the main doc, not switching to suggestion mode\n // In the future, we may want view suggestion mode to be the default, and then we can decide how to indicate that through the options.\n // For now though, we are leaving suggestion mode as experimental and must be explicitly enabled through the SuggestionsExtension.\n }),\n );\n };\n\n if (\n options.provider &&\n \"synced\" in options.provider &&\n typeof options.provider.synced === \"boolean\"\n ) {\n if (options.provider[\"synced\"]) {\n configure();\n } else if (\n \"on\" in options.provider &&\n typeof options.provider.on === \"function\"\n ) {\n options.provider.on(\"synced\", (synced: boolean) => {\n if (synced) {\n configure();\n }\n });\n } else {\n throw new Error(\n \"YSyncExtension: provider must have a 'synced' boolean or an 'on' method to listen for 'sync'\",\n );\n }\n } else {\n configure();\n }\n },\n prosemirrorPlugins: [\n syncPlugin({\n suggestionDoc: options.suggestionDoc,\n mapAttributionToMark,\n // Node-pairing policy for the PM->Y diff: a `blockContainer` whose\n // block-content type changes is treated as a *different* node, so the\n // diff replaces the whole container (deleted + inserted siblings in\n // the blockGroup) instead of producing two block-contents in one\n // container => schema-invalid. No schema change / storage transform\n // needed; `blockContainer` already whitelists the `y-attributed-*`\n // marks. See blockMatchNodes.ts.\n customCompare: blockMatchNodes,\n }),\n ],\n runsBefore: [\"default\"],\n } as const;\n },\n);\n","import {\n deltaAttributionToFormat,\n deltaToPNode,\n deltaToPSteps,\n docToDelta,\n nodeToDelta,\n pmToFragment,\n} from \"@y/prosemirror\";\nimport * as d from \"lib0/delta\";\nimport { Node } from \"prosemirror-model\";\nimport { Transaction } from \"prosemirror-state\";\nimport {\n type Block,\n type BlockNoteEditor,\n type BlockSchema,\n type InlineContentSchema,\n type PartialBlock,\n type StyleSchema,\n blockToNode,\n docToBlocks,\n} from \"../index.js\";\nimport { blockMatchNodes } from \"./extensions/blockMatchNodes.js\";\nimport { mapAttributionToMark } from \"./extensions/YSync.js\";\n\nimport * as Y from \"@y/y\";\n\n/**\n * Find the equivalent of a Y.Type in another Y.Doc.\n *\n * For root types this looks up the matching shared key; for sub-types it\n * locates the item by its client/clock ID in the target doc's store.\n */\nexport function findTypeInOtherYdoc>(\n ytype: T,\n otherYdoc: Y.Doc,\n): T {\n const ydoc = ytype.doc;\n if (!ydoc) {\n throw new Error(\"type does not have a ydoc\");\n }\n if (ytype._item === null) {\n /**\n * If is a root type, we need to find the root key in the original ydoc\n * and use it to get the type in the other ydoc.\n */\n const rootKey = Array.from(ydoc.share.keys()).find(\n (key) => ydoc.share.get(key) === ytype,\n );\n if (rootKey == null) {\n throw new Error(\"type does not exist in other ydoc\");\n }\n return otherYdoc.get(rootKey as string, ytype.constructor as any) as T;\n } else {\n /**\n * If it is a sub type, we use the item id to find the history type.\n */\n const ytypeItem = ytype._item;\n const otherStructs = otherYdoc.store.clients.get(ytypeItem.id.client) ?? [];\n const itemIndex = Y.findIndexSS(otherStructs, ytypeItem.id.clock);\n const otherItem = otherStructs[itemIndex] as Y.Item | undefined;\n if (!otherItem) {\n throw new Error(\"type does not exist in other ydoc\");\n }\n const otherContent = otherItem.content as Y.ContentType | undefined;\n if (!otherContent) {\n throw new Error(\"type does not exist in other ydoc\");\n }\n return otherContent.type as T;\n }\n}\n\n/**\n * Turn Prosemirror JSON to BlockNote style JSON\n * @param editor BlockNote editor\n * @param json Prosemirror JSON\n * @returns BlockNote style JSON\n */\nexport function _prosemirrorJSONToBlocks<\n BSchema extends BlockSchema,\n ISchema extends InlineContentSchema,\n SSchema extends StyleSchema,\n>(editor: BlockNoteEditor, json: any) {\n // note: theoretically this should also be possible without creating prosemirror nodes,\n // but this is definitely the easiest way\n const doc = editor.pmSchema.nodeFromJSON(json);\n return docToBlocks(doc);\n}\n\n/**\n * Turn BlockNote JSON to Prosemirror node / state\n * @param editor BlockNote editor\n * @param blocks BlockNote blocks\n * @returns Prosemirror root node\n */\nexport function _blocksToProsemirrorNode<\n BSchema extends BlockSchema,\n ISchema extends InlineContentSchema,\n SSchema extends StyleSchema,\n>(\n editor: BlockNoteEditor,\n blocks: PartialBlock[],\n) {\n const pmNodes = blocks.map((b) => blockToNode(b, editor.pmSchema));\n\n const doc = editor.pmSchema.topNodeType.create(\n null,\n editor.pmSchema.nodes[\"blockGroup\"].create(null, pmNodes),\n );\n return doc;\n}\n\n/** YJS / BLOCKNOTE conversions */\n\n/**\n * Turn a Y.Type collaborative doc into a BlockNote document (BlockNote style JSON of all blocks)\n * @param editor BlockNote editor\n * @param fragment Y.Type\n * @returns BlockNote document (BlockNote style JSON of all blocks)\n */\nexport function yfragmentToBlocks<\n BSchema extends BlockSchema,\n ISchema extends InlineContentSchema,\n SSchema extends StyleSchema,\n>(editor: BlockNoteEditor, fragment: Y.Type) {\n const pmNode = deltaToPNode(fragment.toDeltaDeep(), editor.pmSchema, null);\n if (pmNode === null) {\n return [];\n }\n return docToBlocks(pmNode);\n}\n\n/**\n * Convert blocks to a Y.Type\n *\n * This can be used when importing existing content to Y.Doc for the first time,\n * note that this should not be used to rehydrate a Y.Doc from a database once\n * collaboration has begun as all history will be lost\n *\n * @param editor BlockNote editor\n * @param blocks the blocks to convert\n * @param fragment XML fragment name\n * @returns Y.Type\n */\nexport function blocksToYType<\n BSchema extends BlockSchema,\n ISchema extends InlineContentSchema,\n SSchema extends StyleSchema,\n>(\n editor: BlockNoteEditor,\n blocks: Block[],\n fragment?: Y.Type,\n) {\n if (!fragment) {\n fragment = new Y.Doc().get(\"prosemirror\");\n }\n return pmToFragment(_blocksToProsemirrorNode(editor, blocks), fragment);\n}\n\n/**\n * Turn a Y.Doc collaborative doc into a BlockNote document (BlockNote style JSON of all blocks)\n * @param editor BlockNote editor\n * @param ydoc Y.Doc\n * @param fragment XML fragment name\n * @returns BlockNote document (BlockNote style JSON of all blocks)\n */\nexport function yDocToBlocks<\n BSchema extends BlockSchema,\n ISchema extends InlineContentSchema,\n SSchema extends StyleSchema,\n>(\n editor: BlockNoteEditor,\n ydoc: Y.Doc,\n fragment = \"prosemirror\",\n) {\n return yfragmentToBlocks(editor, ydoc.get(fragment));\n}\n\n/**\n * This can be used when importing existing content to Y.Doc for the first time,\n * note that this should not be used to rehydrate a Y.Doc from a database once\n * collaboration has begun as all history will be lost\n *\n * @param editor BlockNote editor\n * @param blocks the blocks to convert\n * @param fragment XML fragment name\n */\nexport function blocksToYDoc<\n BSchema extends BlockSchema,\n ISchema extends InlineContentSchema,\n SSchema extends StyleSchema,\n>(\n editor: BlockNoteEditor,\n blocks: PartialBlock[],\n fragment = \"prosemirror\",\n) {\n const delta = docToDelta(_blocksToProsemirrorNode(editor, blocks));\n const doc = new Y.Doc();\n doc.get(fragment).applyDelta(delta);\n return doc;\n}\n\n/**\n * Diff two ProseMirror documents into a delta, using BlockNote's node-pairing\n * policy ({@link blockMatchNodes}) so a block's content-type change is reported\n * as a replace rather than a schema-invalid in-place edit.\n */\nexport function docDiffToDelta(previousDoc: Node, newDoc: Node) {\n const initialDelta = nodeToDelta(previousDoc);\n const finalDelta = nodeToDelta(newDoc);\n return d.diff(initialDelta.done(), finalDelta.done(), {\n compare: blockMatchNodes,\n });\n}\n\n/**\n * Build a ProseMirror transaction that turns `tr.doc` into the content of a\n * Y.Type `fragment`, applying the `renderer`'s authorship as\n * `y-attributed-*` marks. Used to render a (read-only) diff of a snapshot / a\n * version comparison into the editor.\n */\nexport function getProseMirrorTrFromYFragment({\n tr,\n fragment,\n renderer,\n}: {\n tr: Transaction;\n fragment: Y.Type;\n renderer?: Y.AbstractRenderer | null;\n}): Transaction {\n const ycontent = deltaAttributionToFormat(\n fragment.toDeltaDeep({ renderer }),\n mapAttributionToMark,\n );\n // @todo it is preferred to apply the minimal diff - at least for debugging purposes. the\n // document replacal is more reliable though\n\n const pcontent = nodeToDelta(tr.doc, undefined, true);\n const diff = d.diff(pcontent.done(), ycontent.done(), {\n compare: blockMatchNodes,\n });\n return deltaToPSteps(tr, diff, undefined, undefined);\n}\n","import { getMarkRange, posToDOMRect } from \"@tiptap/core\";\n\nimport {\n createExtension,\n ExtensionOptions,\n} from \"../../editor/BlockNoteExtension.js\";\nimport {\n acceptChanges,\n rejectAllChanges,\n rejectChanges,\n configureYProsemirror,\n acceptAllChanges,\n} from \"@y/prosemirror\";\nimport { CollaborationOptions } from \"./index.js\";\nimport { findTypeInOtherYdoc } from \"../utils.js\";\nimport { normalizeToUserStore } from \"../../user/index.js\";\n\nexport const SuggestionsExtension = createExtension(\n ({ editor, options }: ExtensionOptions) => {\n const suggestionDoc = options.suggestionDoc;\n if (!suggestionDoc) {\n throw new Error(\"Suggestion doc not found\");\n }\n // Shared with the rest of collaboration; the collaboration extension passes\n // an already-built store here.\n const userStore = normalizeToUserStore(options.resolveUsers);\n\n function getSuggestionElementAtPos(pos: number) {\n let currentNode = editor.prosemirrorView.nodeDOM(pos);\n while (currentNode && currentNode.parentElement) {\n if (currentNode.nodeName === \"INS\" || currentNode.nodeName === \"DEL\") {\n return currentNode as HTMLElement;\n }\n currentNode = currentNode.parentElement;\n }\n return null;\n }\n\n function getMarkAtPos(pos: number, markType: string) {\n return editor.transact((tr) => {\n const resolvedPos = tr.doc.resolve(pos);\n const mark = resolvedPos\n .marks()\n .find((mark) => mark.type.name === markType);\n\n if (!mark) {\n return;\n }\n\n const markRange = getMarkRange(resolvedPos, mark.type);\n if (!markRange) {\n return;\n }\n\n return {\n range: markRange,\n mark,\n get text() {\n return tr.doc.textBetween(markRange.from, markRange.to);\n },\n get position() {\n // to minimize re-renders, we convert to JSON, which is the same shape anyway\n return posToDOMRect(\n editor.prosemirrorView,\n markRange.from,\n markRange.to,\n ).toJSON() as DOMRect;\n },\n };\n });\n }\n\n function getSuggestionAtSelection() {\n return editor.transact((tr) => {\n const selection = tr.selection;\n if (!selection.empty) {\n return undefined;\n }\n return (\n getMarkAtPos(selection.anchor, \"insertion\") ||\n getMarkAtPos(selection.anchor, \"deletion\") ||\n getMarkAtPos(selection.anchor, \"modification\")\n );\n });\n }\n\n return {\n key: \"suggestions\",\n userStore,\n runsBefore: [\"ySync\"],\n viewSuggestions: () => {\n if (options.renderer) {\n options.renderer.suggestionMode = false;\n }\n editor.exec(\n configureYProsemirror({\n ytype: findTypeInOtherYdoc(options.fragment, suggestionDoc),\n renderer: options.renderer,\n }),\n );\n },\n enableSuggestions: () => {\n if (options.renderer) {\n options.renderer.suggestionMode = true;\n }\n editor.exec(\n configureYProsemirror({\n ytype: findTypeInOtherYdoc(options.fragment, suggestionDoc),\n renderer: options.renderer,\n }),\n );\n },\n disableSuggestions: () => {\n editor.exec(\n configureYProsemirror({\n ytype: options.fragment,\n renderer: null,\n }),\n );\n },\n applyAllSuggestions: () => {\n return editor.exec(acceptAllChanges());\n },\n applySuggestion: (start: number, end?: number) => {\n return editor.exec(acceptChanges(start, end));\n },\n revertSuggestion: (start: number, end?: number) => {\n return editor.exec(rejectChanges(start, end));\n },\n revertAllSuggestions: () => {\n return editor.exec(rejectAllChanges());\n },\n\n getSuggestionElementAtPos,\n getMarkAtPos,\n getSuggestionAtSelection,\n getSuggestionAtCoords: (coords: { left: number; top: number }) => {\n return editor.transact(() => {\n const posAtCoords = editor.prosemirrorView.posAtCoords(coords);\n if (posAtCoords === null || posAtCoords?.inside === -1) {\n return undefined;\n }\n\n return (\n getMarkAtPos(posAtCoords.pos, \"y-attributed-insert\") ||\n getMarkAtPos(posAtCoords.pos, \"y-attributed-delete\") ||\n getMarkAtPos(posAtCoords.pos, \"y-attributed-format\")\n );\n });\n },\n checkUnresolvedSuggestions: () => {\n let hasUnresolvedSuggestions = false;\n\n editor.prosemirrorState.doc.descendants((node) => {\n if (hasUnresolvedSuggestions) {\n return false;\n }\n\n hasUnresolvedSuggestions =\n node.marks.findIndex(\n (mark) =>\n mark.type.name === \"y-attributed-insert\" ||\n mark.type.name === \"y-attributed-delete\" ||\n mark.type.name === \"y-attributed-format\",\n ) !== -1;\n\n return true;\n });\n\n return hasUnresolvedSuggestions;\n },\n } as const;\n },\n);\n","import { configureYProsemirror, pauseSync } from \"@y/prosemirror\";\nimport * as Y from \"@y/y\";\n\nimport type { BlockNoteEditor } from \"../../editor/BlockNoteEditor.js\";\nimport type { PreviewController } from \"../../extensions/Versioning/index.js\";\nimport {\n findTypeInOtherYdoc,\n getProseMirrorTrFromYFragment,\n} from \"../utils.js\";\n\n/**\n * Empties the document before a {@link configureYProsemirror} refill so\n * ProseMirror rebuilds every node view instead of reusing a stale-positioned one\n * (BlockNote node views resolve their block eagerly via `getPos()` and throw on\n * a moved node). Sync is paused first so the clear never reaches the Y.Doc.\n *\n * TODO: remove once `configureYProsemirror` applies a minimal diff.\n */\nfunction clearDocumentForConfigure(editor: BlockNoteEditor) {\n // Pause sync (ytype -> null) so the deletion below stays local.\n editor.exec(pauseSync);\n editor.removeBlocks(editor.document);\n}\n\n/**\n * Creates a Yjs-specific adapter that provides the {@link PreviewController}\n * and `getCurrentDocument` callback required by the base\n * {@link VersioningExtension}.\n *\n * This is wired automatically by the {@link CollaborationExtension} when\n * `versioningEndpoints` is provided. You only need to call this directly if\n * you're using the `VersioningExtension` outside of the collaboration wrapper.\n */\nexport function createYjsVersioningAdapter(\n editor: BlockNoteEditor,\n fragment: Y.Type,\n): {\n preview: PreviewController;\n getCurrentDocument: () => Y.Type;\n serializeCurrentContent: () => Uint8Array;\n} {\n return {\n getCurrentDocument: () => fragment,\n // Serialise the live document as a V2 update — the same format that\n // `getContent` returns (via `convertUpdateFormatV1ToV2`) and that\n // `enterPreview` consumes (`applyUpdateV2`). Used to render a read-only\n // diff of the live document against a snapshot.\n serializeCurrentContent: () => Y.encodeStateAsUpdateV2(fragment.doc!),\n preview: {\n enterPreview: (\n snapshotContent: Uint8Array,\n compareToContent?: Uint8Array,\n attributions?: Y.ContentMap,\n ) => {\n let prevSnapshot: { fragment: Y.Type } | undefined;\n if (compareToContent) {\n const compareToDoc = new Y.Doc({ isSuggestionDoc: true });\n Y.applyUpdateV2(compareToDoc, compareToContent);\n prevSnapshot = {\n fragment: findTypeInOtherYdoc(fragment, compareToDoc),\n };\n }\n\n const doc = new Y.Doc();\n Y.applyUpdateV2(doc, snapshotContent);\n // Empty the document before reconfiguring so ProseMirror rebuilds node\n // views from scratch instead of reusing stale-positioned ones. See\n // clearDocumentForConfigure.\n clearDocumentForConfigure(editor);\n\n editor.exec((state, dispatch) => {\n const tr = getProseMirrorTrFromYFragment({\n tr: state.tr,\n fragment: findTypeInOtherYdoc(fragment, doc),\n // Pass the optional content map as `attrs` so the diff renderer\n // knows who/when authored each change. Without it, the renderer\n // only produces \"what changed\" (empty userIds, null timestamps) and\n // downstream mark tooltips show \"unknown / unknown time\".\n renderer: prevSnapshot\n ? Y.createDiffRenderer(\n prevSnapshot.fragment.doc!,\n doc,\n attributions ? { attrs: attributions } : undefined,\n )\n : undefined,\n });\n if (dispatch) {\n dispatch(tr);\n }\n return true;\n });\n },\n exitPreview: () => {\n // Empty the document before reconfiguring so ProseMirror rebuilds node\n // views from scratch instead of reusing stale-positioned ones. See\n // clearDocumentForConfigure.\n clearDocumentForConfigure(editor);\n editor.exec(configureYProsemirror({ ytype: fragment }));\n },\n applyRestore: (_snapshotContent: Uint8Array) => {\n // For Yjs-backed versioning, restoration happens on the server (e.g.\n // YHub's `/rollback` endpoint) which publishes a reverting update to\n // the document's room. That update propagates back to this client over\n // the live sync connection and updates `fragment` automatically, so\n // there is nothing to apply locally — we only need to leave preview\n // mode. `exitPreview` is already called by the base extension before\n // this runs, so this is a no-op.\n //\n // Note: this assumes `endpoints.restore` performs the server-side\n // restore. The default in-memory adapter has no server, which is why\n // this is specific to the Yjs collaboration setup.\n },\n },\n };\n}\n","import { defaultSelectionBuilder, yCursorPlugin } from \"@y/prosemirror\";\nimport {\n createExtension,\n ExtensionOptions,\n} from \"../../editor/BlockNoteExtension.js\";\nimport { CollaborationOptions } from \"./index.js\";\n\nexport type CollaborationUser = {\n id?: string;\n name: string;\n color: string;\n [key: string]: unknown;\n};\n\n/**\n * Determine whether the foreground color should be white or black based on a provided background color\n * Inspired by: https://stackoverflow.com/a/3943023\n */\nfunction isDarkColor(bgColor: string): boolean {\n const color = bgColor.charAt(0) === \"#\" ? bgColor.substring(1, 7) : bgColor;\n const r = parseInt(color.substring(0, 2), 16); // hexToR\n const g = parseInt(color.substring(2, 4), 16); // hexToG\n const b = parseInt(color.substring(4, 6), 16); // hexToB\n const uicolors = [r / 255, g / 255, b / 255];\n const c = uicolors.map((col) => {\n if (col <= 0.03928) {\n return col / 12.92;\n }\n return Math.pow((col + 0.055) / 1.055, 2.4);\n });\n const L = 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];\n return L <= 0.179;\n}\n\nfunction defaultCursorRender(user: CollaborationUser) {\n const cursorElement = document.createElement(\"span\");\n\n cursorElement.classList.add(\"bn-collaboration-cursor__base\");\n\n const caretElement = document.createElement(\"span\");\n caretElement.setAttribute(\"contentedEditable\", \"false\");\n caretElement.classList.add(\"bn-collaboration-cursor__caret\");\n caretElement.setAttribute(\n \"style\",\n `background-color: ${user.color}; color: ${\n isDarkColor(user.color) ? \"white\" : \"black\"\n }`,\n );\n\n const labelElement = document.createElement(\"span\");\n\n labelElement.classList.add(\"bn-collaboration-cursor__label\");\n labelElement.setAttribute(\n \"style\",\n `background-color: ${user.color}; color: ${\n isDarkColor(user.color) ? \"white\" : \"black\"\n }`,\n );\n labelElement.insertBefore(document.createTextNode(user.name), null);\n\n caretElement.insertBefore(labelElement, null);\n\n cursorElement.insertBefore(document.createTextNode(\"\\u2060\"), null); // Non-breaking space\n cursorElement.insertBefore(caretElement, null);\n cursorElement.insertBefore(document.createTextNode(\"\\u2060\"), null); // Non-breaking space\n\n return cursorElement;\n}\n\nexport const YCursorExtension = createExtension(\n ({ options }: ExtensionOptions) => {\n const recentlyUpdatedCursors = new Map();\n const awareness =\n options.provider &&\n \"awareness\" in options.provider &&\n typeof options.provider.awareness === \"object\"\n ? options.provider.awareness\n : undefined;\n if (awareness) {\n if (\n \"setLocalStateField\" in awareness &&\n typeof awareness.setLocalStateField === \"function\"\n ) {\n awareness.setLocalStateField(\"user\", options.user);\n }\n if (\"on\" in awareness && typeof awareness.on === \"function\") {\n if (options.showCursorLabels !== \"always\") {\n awareness.on(\n \"change\",\n ({\n updated,\n }: {\n added: Array;\n updated: Array;\n removed: Array;\n }) => {\n for (const clientID of updated) {\n const cursor = recentlyUpdatedCursors.get(clientID);\n\n if (cursor) {\n setTimeout(() => {\n cursor.element.setAttribute(\"data-active\", \"\");\n }, 10);\n\n if (cursor.hideTimeout) {\n clearTimeout(cursor.hideTimeout);\n }\n\n recentlyUpdatedCursors.set(clientID, {\n element: cursor.element,\n hideTimeout: setTimeout(() => {\n cursor.element.removeAttribute(\"data-active\");\n }, 2000),\n });\n }\n }\n },\n );\n }\n }\n }\n\n return {\n key: \"yCursor\",\n prosemirrorPlugins: [\n awareness\n ? yCursorPlugin(awareness, {\n selectionBuilder: defaultSelectionBuilder,\n cursorBuilder(user, clientID) {\n let cursorData = recentlyUpdatedCursors.get(clientID);\n\n if (!cursorData) {\n const cursorElement = (\n options.renderCursor ?? defaultCursorRender\n )(user as CollaborationUser);\n\n if (options.showCursorLabels !== \"always\") {\n cursorElement.addEventListener(\"mouseenter\", () => {\n const cursor = recentlyUpdatedCursors.get(clientID)!;\n cursor.element.setAttribute(\"data-active\", \"\");\n\n if (cursor.hideTimeout) {\n clearTimeout(cursor.hideTimeout);\n recentlyUpdatedCursors.set(clientID, {\n element: cursor.element,\n hideTimeout: undefined,\n });\n }\n });\n\n cursorElement.addEventListener(\"mouseleave\", () => {\n const cursor = recentlyUpdatedCursors.get(clientID)!;\n\n recentlyUpdatedCursors.set(clientID, {\n element: cursor.element,\n hideTimeout: setTimeout(() => {\n cursor.element.removeAttribute(\"data-active\");\n }, 2000),\n });\n });\n }\n\n cursorData = {\n element: cursorElement,\n hideTimeout: undefined,\n };\n\n recentlyUpdatedCursors.set(clientID, cursorData);\n }\n\n return cursorData.element;\n },\n })\n : undefined,\n ].filter((a) => a !== undefined),\n dependsOn: [\"ySync\"],\n updateUser(user: CollaborationUser) {\n awareness?.setLocalStateField(\"user\", user);\n },\n getUser(): CollaborationUser | undefined {\n const state = awareness?.getLocalState();\n if (!state) {\n return undefined;\n }\n return state[\"user\"];\n },\n } as const;\n },\n);\n","import { docToDelta } from \"@y/prosemirror\";\nimport * as Y from \"@y/y\";\n\nimport type { Block } from \"../../blocks/defaultBlocks.js\";\nimport type { BlockNoteEditor } from \"../../editor/BlockNoteEditor.js\";\nimport { createExtension } from \"../../editor/BlockNoteExtension.js\";\nimport type { User } from \"../../user/index.js\";\nimport {\n _blocksToProsemirrorNode,\n docDiffToDelta,\n findTypeInOtherYdoc,\n getProseMirrorTrFromYFragment,\n} from \"../utils.js\";\nimport { AttributionExtension } from \"./AttributionExtension.js\";\nimport type { GetAttributionMarkClassName } from \"./YAttributionMarks.js\";\n\n/**\n * A version diff has a single \"author\" — the version that introduced the changes\n * — not a real user, so all `y-attributed-*` marks carry one synthetic id. That\n * id is derived from the version's label (see {@link diffAuthorId}) so it's stable\n * per version: the user store caches resolved users by id, so a per-label id keeps\n * each version's tooltip showing its own name instead of a stale cached one.\n */\nconst DIFF_AUTHOR_ID_PREFIX = \"version:\";\n\n/** The synthetic author id for a given version label. */\nconst diffAuthorId = (label: string) => DIFF_AUTHOR_ID_PREFIX + label;\n\n/** Fallback label used when a diff is rendered without a version name. */\nconst DEFAULT_DIFF_LABEL = \"This version\";\n\n/** Color used for the version diff marks. */\nconst DIFF_AUTHOR_COLOR = \"#4363d8\";\n\nexport type DiffVersioningExtensionOptions = {\n /**\n * The color used for the diff's attribution marks. Defaults to a blue.\n */\n color?: string;\n /**\n * See {@link GetAttributionMarkClassName}. Forwarded to the underlying\n * {@link AttributionExtension} to override mark styling by change type.\n */\n getAttributionMarkClassName?: GetAttributionMarkClassName;\n};\n\n/**\n * Records the author of each transaction on `doc` into a mutable\n * {@link Y.Attributions}, so the resulting attribution marks carry a non-empty\n * `userIds` (and therefore resolve to a color/name). The listener must be\n * attached *before* the attributed transaction runs. Mirrors the store used by\n * the suggestion gallery example (`createAttributionStore`).\n */\nfunction attributeTransactionsTo(doc: Y.Doc, userId: string): Y.Attributions {\n const attrs = new Y.Attributions();\n doc.on(\"beforeObserverCalls\", (tr) => {\n if (!tr.insertSet.isEmpty()) {\n Y.insertIntoIdMap(\n attrs.inserts,\n Y.createIdMapFromIdSet(tr.insertSet, [\n Y.createContentAttribute(\"insert\", userId),\n ]),\n );\n }\n if (!tr.deleteSet.isEmpty()) {\n Y.insertIntoIdMap(\n attrs.deletes,\n Y.createIdMapFromIdSet(tr.deleteSet, [\n Y.createContentAttribute(\"delete\", userId),\n ]),\n );\n }\n });\n return attrs;\n}\n\n/**\n * An opt-in extension that renders a read-only diff between two BlockNote\n * documents (`Block[]`) directly in the editor, marking insertions/deletions\n * with the `y-attributed-*` suggestion marks — the same visual result the Yjs\n * collaboration adapter produces, but driven from two plain block arrays with\n * no server and no live Yjs sync.\n *\n * It composes {@link AttributionExtension} (which registers the attribution\n * marks and drives their colors + hover tooltips from a user store), and adds\n * the {@link renderDiff} / {@link clearDiff} capability.\n *\n * Registering this extension is what makes non-collaborative versioning\n * (`inMemoryVersioning`) capable of showing diffs: the in-memory preview\n * controller looks this up by key (`\"diffVersioning\"`) and delegates to\n * {@link renderDiff}, falling back to a static document swap when it's absent.\n *\n * `renderDiff` is also a standalone, directly-callable API — you can register\n * just this extension and call\n * `editor.getExtension(DiffVersioningExtension).renderDiff(target, baseline)`\n * to render a known diff (e.g. in tests).\n *\n * @example\n * ```ts\n * const editor = BlockNoteEditor.create({\n * extensions: [DiffVersioningExtension()],\n * });\n * editor.getExtension(DiffVersioningExtension)!.renderDiff(target, baseline);\n * ```\n */\nexport const DiffVersioningExtension = createExtension(\n ({\n options,\n editor,\n }: {\n options: DiffVersioningExtensionOptions | undefined;\n editor: BlockNoteEditor;\n }) => {\n const color = options?.color ?? DIFF_AUTHOR_COLOR;\n\n // Resolve a synthetic author id back to its version label. The id encodes\n // the label (`version: