@harbour-enterprises/superdoc 1.0.0-beta.92 → 1.0.0-beta.94

package/dist/superdoc.umd.js

@@ -42398,7 +42398,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     static getStoredSuperdocVersion(docx) {
       return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
     }
-    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.92") {
+    static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-beta.94") {
       return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
     }
     /**
@@ -64405,12 +64405,12 @@ Please report this to https://github.com/markedjs/marked.`, e) {
     const { doc: doc2 } = tr;
     const startPos = Math.max(from2 - offset2, 0);
     const endPos = Math.min(to + offset2, doc2.content.size);
-    let markFound;
-    doc2.nodesBetween(startPos, endPos, (node2, pos) => {
+    let markFound = null;
+    const tryMatch = (node2, pos) => {
       if (!node2 || node2?.nodeSize === void 0) {
         return;
       }
-      const mark2 = node2.marks.find(
+      const mark2 = node2.marks?.find(
         (mark22) => mark22.type.name === markName && Object.keys(attrs).every((attr) => mark22.attrs[attr] === attrs[attr])
       );
       if (mark2 && !markFound) {
@@ -64419,24 +64419,36 @@ Please report this to https://github.com/markedjs/marked.`, e) {
           to: pos + node2.nodeSize,
           mark: mark2
         };
+        return false;
       }
+    };
+    doc2.nodesBetween(startPos, endPos, (node2, pos) => {
+      return tryMatch(node2, pos);
     });
-    const nodeAtEndPosition = doc2.nodeAt(endPos);
-    if (nodeAtEndPosition?.type?.name === "run") {
-      const node2 = nodeAtEndPosition.content?.content?.[0];
-      const isTextNode = node2?.type?.name === "text";
-      if (isTextNode) {
-        const mark2 = node2.marks.find(
-          (mark22) => mark22.type.name === markName && Object.keys(attrs).every((attr) => mark22.attrs[attr] === attrs[attr])
-        );
-        if (mark2 && !markFound) {
-          markFound = {
-            from: endPos,
-            to: endPos + node2.nodeSize,
-            mark: mark2
-          };
+    const inspectAroundPosition = (pos) => {
+      if (pos < 0 || pos > doc2.content.size) {
+        return;
+      }
+      const resolved = doc2.resolve(pos);
+      const before = resolved.nodeBefore;
+      if (before?.type?.name === "run") {
+        const beforeStart = Math.max(pos - before.nodeSize, 0);
+        const node2 = before.content?.content?.[0];
+        if (node2?.type?.name === "text") {
+          tryMatch(node2, beforeStart);
+        }
+      }
+      const after = resolved.nodeAfter;
+      if (after?.type?.name === "run") {
+        const node2 = after.content?.content?.[0];
+        if (node2?.type?.name === "text") {
+          tryMatch(node2, pos);
         }
       }
+    };
+    if (!markFound) {
+      inspectAroundPosition(startPos);
+      inspectAroundPosition(endPos);
     }
     return markFound;
   };
@@ -67461,7 +67473,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
   const shouldSkipNodeView = (editor) => {
     return isHeadless(editor);
   };
-  const summaryVersion = "1.0.0-beta.92";
+  const summaryVersion = "1.0.0-beta.94";
   const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
   const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
   function mapAttributes(attrs) {
@@ -68250,7 +68262,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
         { default: remarkStringify2 },
         { default: remarkGfm2 }
       ] = await Promise.all([
-        Promise.resolve().then(() => indexCqnVFwjL),
+        Promise.resolve().then(() => indexBstIHBcW),
         Promise.resolve().then(() => indexDRCvimau),
         Promise.resolve().then(() => indexC_x_N6Uh),
         Promise.resolve().then(() => indexD_sWOSiG),
@@ -68455,7 +68467,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
      * Process collaboration migrations
      */
     processCollaborationMigrations() {
-      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.92");
+      console.debug("[checkVersionMigrations] Current editor version", "1.0.0-beta.94");
       if (!this.options.ydoc) return;
       const metaMap = this.options.ydoc.getMap("meta");
       let docVersion = metaMap.get("version");
@@ -85332,10 +85344,31 @@ ${l}
           textRun.letterSpacing != null ? textRun.letterSpacing : "",
           textRun.pmStart ?? "",
           textRun.pmEnd ?? "",
-          textRun.token ?? ""
+          textRun.token ?? "",
+          // Tracked changes - force re-render when added or removed tracked change
+          textRun.trackedChange ? 1 : 0
         ].join(",");
       }).join("|");
-      return markerVersion ? `${markerVersion}|${runsVersion}` : runsVersion;
+      const attrs = block.attrs;
+      const paragraphAttrsVersion = attrs ? [
+        attrs.alignment ?? "",
+        attrs.spacing?.before ?? "",
+        attrs.spacing?.after ?? "",
+        attrs.spacing?.line ?? "",
+        attrs.spacing?.lineRule ?? "",
+        attrs.indent?.left ?? "",
+        attrs.indent?.right ?? "",
+        attrs.indent?.firstLine ?? "",
+        attrs.indent?.hanging ?? "",
+        attrs.borders ? JSON.stringify(attrs.borders) : "",
+        attrs.shading?.fill ?? "",
+        attrs.shading?.color ?? "",
+        attrs.direction ?? "",
+        attrs.rtl ? "1" : "",
+        attrs.tabs?.length ? JSON.stringify(attrs.tabs) : ""
+      ].join(":") : "";
+      const parts = [markerVersion, runsVersion, paragraphAttrsVersion].filter(Boolean);
+      return parts.join("|");
     }
     if (block.kind === "list") {
       return block.items.map((item) => `${item.id}:${item.marker.text}:${deriveBlockVersion(item.paragraph)}`).join("|");
@@ -89082,6 +89115,33 @@ ${l}
   const BYTES_PER_ENTRY_ESTIMATE = 5e3;
   const NORMALIZED_WHITESPACE = /\s+/g;
   const normalizeText = (text2) => text2.replace(NORMALIZED_WHITESPACE, " ");
+  const hashParagraphBorder = (border) => {
+    const parts = [];
+    if (border.style !== void 0) parts.push(`s:${border.style}`);
+    if (border.width !== void 0) parts.push(`w:${border.width}`);
+    if (border.color !== void 0) parts.push(`c:${border.color}`);
+    if (border.space !== void 0) parts.push(`sp:${border.space}`);
+    return parts.join(",");
+  };
+  const hashParagraphBorders = (borders) => {
+    const parts = [];
+    if (borders.top) parts.push(`t:[${hashParagraphBorder(borders.top)}]`);
+    if (borders.right) parts.push(`r:[${hashParagraphBorder(borders.right)}]`);
+    if (borders.bottom) parts.push(`b:[${hashParagraphBorder(borders.bottom)}]`);
+    if (borders.left) parts.push(`l:[${hashParagraphBorder(borders.left)}]`);
+    return parts.join(";");
+  };
+  const hashParagraphFrame = (frame) => {
+    const parts = [];
+    if (frame.wrap !== void 0) parts.push(`w:${frame.wrap}`);
+    if (frame.x !== void 0) parts.push(`x:${frame.x}`);
+    if (frame.y !== void 0) parts.push(`y:${frame.y}`);
+    if (frame.xAlign !== void 0) parts.push(`xa:${frame.xAlign}`);
+    if (frame.yAlign !== void 0) parts.push(`ya:${frame.yAlign}`);
+    if (frame.hAnchor !== void 0) parts.push(`ha:${frame.hAnchor}`);
+    if (frame.vAnchor !== void 0) parts.push(`va:${frame.vAnchor}`);
+    return parts.join(",");
+  };
   const hashRuns = (block) => {
     if (block.kind === "table") {
       const tableBlock = block;
@@ -89177,7 +89237,59 @@ ${l}
         numberingKey = `|num:${np.numId ?? ""}:${np.ilvl ?? 0}:${markerTextKey}`;
       }
     }
-    return `${trackedMode}:${trackedEnabled ? "on" : "off"}|${runsHash}${numberingKey}`;
+    let paragraphAttrsKey = "";
+    if (block.attrs) {
+      const attrs = block.attrs;
+      const parts = [];
+      if (attrs.alignment) parts.push(`al:${attrs.alignment}`);
+      if (attrs.spacing) {
+        const s2 = attrs.spacing;
+        if (s2.before !== void 0) parts.push(`sb:${s2.before}`);
+        if (s2.after !== void 0) parts.push(`sa:${s2.after}`);
+        if (s2.line !== void 0) parts.push(`sl:${s2.line}`);
+        if (s2.lineRule) parts.push(`sr:${s2.lineRule}`);
+      }
+      if (attrs.indent) {
+        const ind = attrs.indent;
+        if (ind.left !== void 0) parts.push(`il:${ind.left}`);
+        if (ind.right !== void 0) parts.push(`ir:${ind.right}`);
+        if (ind.firstLine !== void 0) parts.push(`if:${ind.firstLine}`);
+        if (ind.hanging !== void 0) parts.push(`ih:${ind.hanging}`);
+      }
+      if (attrs.borders) {
+        parts.push(`br:${hashParagraphBorders(attrs.borders)}`);
+      }
+      if (attrs.shading) {
+        const sh = attrs.shading;
+        if (sh.fill) parts.push(`shf:${sh.fill}`);
+        if (sh.color) parts.push(`shc:${sh.color}`);
+      }
+      if (attrs.tabs && attrs.tabs.length > 0) {
+        const tabsHash = attrs.tabs.map((t) => `${t.val ?? ""}:${t.pos ?? ""}:${t.leader ?? ""}`).join(",");
+        parts.push(`tb:${tabsHash}`);
+      }
+      if (attrs.direction) parts.push(`dir:${attrs.direction}`);
+      if (attrs.rtl) parts.push("rtl");
+      if (attrs.keepNext) parts.push("kn");
+      if (attrs.keepLines) parts.push("kl");
+      if (attrs.floatAlignment) parts.push(`fa:${attrs.floatAlignment}`);
+      if (attrs.contextualSpacing) parts.push("cs");
+      if (attrs.suppressFirstLineIndent) parts.push("sfi");
+      if (attrs.dropCap) parts.push(`dc:${attrs.dropCap}`);
+      if (attrs.dropCapDescriptor) {
+        const dcd = attrs.dropCapDescriptor;
+        parts.push(`dcd:${dcd.mode ?? ""}:${dcd.lines ?? ""}`);
+      }
+      if (attrs.frame) {
+        parts.push(`fr:${hashParagraphFrame(attrs.frame)}`);
+      }
+      if (attrs.tabIntervalTwips !== void 0) parts.push(`ti:${attrs.tabIntervalTwips}`);
+      if (attrs.decimalSeparator) parts.push(`ds:${attrs.decimalSeparator}`);
+      if (parts.length > 0) {
+        paragraphAttrsKey = `|pa:${parts.join(":")}`;
+      }
+    }
+    return `${trackedMode}:${trackedEnabled ? "on" : "off"}|${runsHash}${numberingKey}${paragraphAttrsKey}`;
   };
   const createStats = () => ({
     hits: 0,
@@ -90062,6 +90174,75 @@ ${l}
     }
     return "";
   };
+  const paragraphSpacingEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    return a2.before === b2.before && a2.after === b2.after && a2.line === b2.line && a2.lineRule === b2.lineRule && a2.beforeAutospacing === b2.beforeAutospacing && a2.afterAutospacing === b2.afterAutospacing;
+  };
+  const paragraphIndentEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    return a2.left === b2.left && a2.right === b2.right && a2.firstLine === b2.firstLine && a2.hanging === b2.hanging;
+  };
+  const paragraphBorderEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    return a2.style === b2.style && a2.width === b2.width && a2.color === b2.color && a2.space === b2.space;
+  };
+  const paragraphBordersEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    return paragraphBorderEqual(a2.top, b2.top) && paragraphBorderEqual(a2.right, b2.right) && paragraphBorderEqual(a2.bottom, b2.bottom) && paragraphBorderEqual(a2.left, b2.left);
+  };
+  const paragraphShadingEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    return a2.fill === b2.fill && a2.color === b2.color && a2.val === b2.val && a2.themeColor === b2.themeColor && a2.themeFill === b2.themeFill && a2.themeFillShade === b2.themeFillShade && a2.themeFillTint === b2.themeFillTint && a2.themeShade === b2.themeShade && a2.themeTint === b2.themeTint;
+  };
+  const tabStopEqual = (a2, b2) => {
+    return a2.val === b2.val && a2.pos === b2.pos && a2.leader === b2.leader;
+  };
+  const tabStopsEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    if (a2.length !== b2.length) return false;
+    for (let i2 = 0; i2 < a2.length; i2 += 1) {
+      if (!tabStopEqual(a2[i2], b2[i2])) return false;
+    }
+    return true;
+  };
+  const paragraphFrameEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    return a2.wrap === b2.wrap && a2.x === b2.x && a2.y === b2.y && a2.xAlign === b2.xAlign && a2.yAlign === b2.yAlign && a2.hAnchor === b2.hAnchor && a2.vAnchor === b2.vAnchor;
+  };
+  const dropCapDescriptorEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    if (a2.mode !== b2.mode || a2.lines !== b2.lines) return false;
+    const runA = a2.run;
+    const runB = b2.run;
+    if (!runA || !runB) return !runA && !runB;
+    if (runA.text !== runB.text || runA.fontFamily !== runB.fontFamily || runA.fontSize !== runB.fontSize || runA.bold !== runB.bold || runA.italic !== runB.italic || runA.color !== runB.color) {
+      return false;
+    }
+    return true;
+  };
+  const paragraphAttrsEqual = (a2, b2) => {
+    if (a2 === b2) return true;
+    if (!a2 || !b2) return !a2 && !b2;
+    if (a2.alignment !== b2.alignment || a2.contextualSpacing !== b2.contextualSpacing || a2.suppressFirstLineIndent !== b2.suppressFirstLineIndent || a2.dropCap !== b2.dropCap || a2.decimalSeparator !== b2.decimalSeparator || a2.tabIntervalTwips !== b2.tabIntervalTwips || a2.keepNext !== b2.keepNext || a2.keepLines !== b2.keepLines || a2.direction !== b2.direction || a2.rtl !== b2.rtl || a2.floatAlignment !== b2.floatAlignment) {
+      return false;
+    }
+    if (!paragraphSpacingEqual(a2.spacing, b2.spacing)) return false;
+    if (!paragraphIndentEqual(a2.indent, b2.indent)) return false;
+    if (!paragraphBordersEqual(a2.borders, b2.borders)) return false;
+    if (!paragraphShadingEqual(a2.shading, b2.shading)) return false;
+    if (!tabStopsEqual(a2.tabs, b2.tabs)) return false;
+    if (!paragraphFrameEqual(a2.frame, b2.frame)) return false;
+    if (!dropCapDescriptorEqual(a2.dropCapDescriptor, b2.dropCapDescriptor)) return false;
+    return true;
+  };
   const paragraphBlocksEqual = (a2, b2) => {
     const aMode = a2.attrs?.trackedChangesMode ?? "review";
     const bMode = b2.attrs?.trackedChangesMode ?? "review";
@@ -90069,6 +90250,7 @@ ${l}
     const aEnabled = resolveTrackedChangesEnabled(a2.attrs, true);
     const bEnabled = resolveTrackedChangesEnabled(b2.attrs, true);
     if (aEnabled !== bEnabled) return false;
+    if (!paragraphAttrsEqual(a2.attrs, b2.attrs)) return false;
     if (a2.runs.length !== b2.runs.length) return false;
     for (let i2 = 0; i2 < a2.runs.length; i2 += 1) {
       const runA = a2.runs[i2];
@@ -92714,6 +92896,104 @@ ${l}
           const wordStartChar = charPosInRun;
           const wordEndNoSpace = charPosInRun + word.length;
           const wordEndWithSpace = charPosInRun + (isLastWord ? word.length : word.length + 1);
+          const effectiveMaxWidth = currentLine ? currentLine.maxWidth : getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
+          if (wordOnlyWidth > effectiveMaxWidth && word.length > 1) {
+            if (currentLine && currentLine.width > 0 && currentLine.segments.length > 0) {
+              const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+              const { spaceCount: _sc, ...lineBase } = currentLine;
+              const completedLine = { ...lineBase, ...metrics };
+              addBarTabsToLine(completedLine);
+              lines.push(completedLine);
+              tabStopCursor = 0;
+              pendingTabAlignment = null;
+              currentLine = null;
+            }
+            const lineMaxWidth = getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
+            const hasTabOnlyLine = currentLine && currentLine.segments.length === 0 && currentLine.width > 0;
+            const remainingWidthAfterTab = hasTabOnlyLine ? currentLine.maxWidth - currentLine.width : lineMaxWidth;
+            const chunkWidth = hasTabOnlyLine ? Math.max(remainingWidthAfterTab, lineMaxWidth * 0.25) : lineMaxWidth;
+            const chunks = breakWordIntoChunks(word, chunkWidth - WIDTH_FUDGE_PX, font, ctx2, run2);
+            let chunkCharOffset = wordStartChar;
+            for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+              const chunk = chunks[chunkIndex];
+              const chunkStartChar = chunkCharOffset;
+              const chunkEndChar = chunkCharOffset + chunk.text.length;
+              const isLastChunk = chunkIndex === chunks.length - 1;
+              const isFirstChunk = chunkIndex === 0;
+              if (isFirstChunk && hasTabOnlyLine && currentLine) {
+                currentLine.toRun = runIndex;
+                currentLine.toChar = chunkEndChar;
+                currentLine.width = roundValue(currentLine.width + chunk.width);
+                currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
+                currentLine.maxFontInfo = getFontInfoFromRun(run2);
+                currentLine.segments.push({
+                  runIndex,
+                  fromChar: chunkStartChar,
+                  toChar: chunkEndChar,
+                  width: chunk.width
+                });
+                if (isLastChunk) {
+                  const ls = run2.letterSpacing ?? 0;
+                  if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX) {
+                    currentLine.toChar = wordEndWithSpace;
+                    currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
+                    charPosInRun = wordEndWithSpace;
+                    currentLine.spaceCount += 1;
+                  } else {
+                    charPosInRun = wordEndWithSpace;
+                  }
+                } else {
+                  const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
+                  const { spaceCount: _sc, ...lineBase } = currentLine;
+                  const completedLine = { ...lineBase, ...metrics };
+                  addBarTabsToLine(completedLine);
+                  lines.push(completedLine);
+                  tabStopCursor = 0;
+                  pendingTabAlignment = null;
+                  currentLine = null;
+                }
+              } else if (isLastChunk) {
+                currentLine = {
+                  fromRun: runIndex,
+                  fromChar: chunkStartChar,
+                  toRun: runIndex,
+                  toChar: chunkEndChar,
+                  width: chunk.width,
+                  maxFontSize: run2.fontSize,
+                  maxFontInfo: getFontInfoFromRun(run2),
+                  maxWidth: getEffectiveWidth(contentWidth),
+                  segments: [{ runIndex, fromChar: chunkStartChar, toChar: chunkEndChar, width: chunk.width }],
+                  spaceCount: 0
+                };
+                const ls = run2.letterSpacing ?? 0;
+                if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX) {
+                  currentLine.toChar = wordEndWithSpace;
+                  currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
+                  charPosInRun = wordEndWithSpace;
+                  currentLine.spaceCount += 1;
+                } else {
+                  charPosInRun = wordEndWithSpace;
+                }
+              } else {
+                const chunkLineMaxWidth = getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
+                const metrics = calculateTypographyMetrics(run2.fontSize, spacing, getFontInfoFromRun(run2));
+                const chunkLine = {
+                  fromRun: runIndex,
+                  fromChar: chunkStartChar,
+                  toRun: runIndex,
+                  toChar: chunkEndChar,
+                  width: chunk.width,
+                  maxWidth: chunkLineMaxWidth,
+                  segments: [{ runIndex, fromChar: chunkStartChar, toChar: chunkEndChar, width: chunk.width }],
+                  ...metrics
+                };
+                addBarTabsToLine(chunkLine);
+                lines.push(chunkLine);
+              }
+              chunkCharOffset = chunkEndChar;
+            }
+            continue;
+          }
           if (!currentLine) {
             currentLine = {
               fromRun: runIndex,
@@ -93292,6 +93572,35 @@ ${l}
     const width = getMeasuredTextWidth(text2, font, letterSpacing, ctx2);
     return roundValue(width);
   };
+  const breakWordIntoChunks = (word, maxWidth, font, ctx2, run2) => {
+    const chunks = [];
+    if (maxWidth <= 0) {
+      for (const char of word) {
+        const charWidth = measureRunWidth(char, font, ctx2, run2);
+        chunks.push({ text: char, width: charWidth });
+      }
+      return chunks;
+    }
+    let currentChunk = "";
+    let currentWidth = 0;
+    for (let i2 = 0; i2 < word.length; i2++) {
+      const char = word[i2];
+      const testChunk = currentChunk + char;
+      const testWidth = measureRunWidth(testChunk, font, ctx2, run2);
+      if (testWidth > maxWidth && currentChunk.length > 0) {
+        chunks.push({ text: currentChunk, width: currentWidth });
+        currentChunk = char;
+        currentWidth = measureRunWidth(char, font, ctx2, run2);
+      } else {
+        currentChunk = testChunk;
+        currentWidth = testWidth;
+      }
+    }
+    if (currentChunk.length > 0) {
+      chunks.push({ text: currentChunk, width: currentWidth });
+    }
+    return chunks;
+  };
   const appendSegment = (segments, runIndex, fromChar, toChar, width, x2) => {
     if (!segments) return;
     const last = segments[segments.length - 1];
@@ -151617,7 +151926,7 @@ ${style2}
       this.config.colors = shuffleArray(this.config.colors);
       this.userColorMap = /* @__PURE__ */ new Map();
       this.colorIndex = 0;
-      this.version = "1.0.0-beta.92";
+      this.version = "1.0.0-beta.94";
       this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
       this.superdocId = config2.superdocId || v4();
       this.colors = this.config.colors;
@@ -154089,7 +154398,7 @@ ${style2}
       value && typeof value === "object" && "byteLength" in value && "byteOffset" in value
     );
   }
-  const indexCqnVFwjL = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  const indexBstIHBcW = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
     unified
   }, Symbol.toStringTag, { value: "Module" }));