@seed-hypermedia/client 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -1,5 +1,7 @@
 import {
   HMActionSchema,
+  HMBlockButtonAlignmentSchema,
+  HMBlockSchema,
   HMRequestSchema,
   HYPERMEDIA_SCHEME,
   codePointLength,
@@ -12,8 +14,9 @@ import {
   parseCustomURL,
   parseFragment,
   serializeBlockRange,
+  toNumber,
   unpackHmId
-} from "./chunk-X57BIZUK.mjs";
+} from "./chunk-B5WCMFR5.mjs";
 
 // src/capability.ts
 import { encode as cborEncode2 } from "@ipld/dag-cbor";
@@ -792,6 +795,33 @@ async function deleteComment(input, signer) {
   const encoded = cborEncode6(tombstone);
   return toPublishInput(encoded, []);
 }
+async function updateComment(input, signer) {
+  const parts = input.commentId.split("/");
+  const tsid = parts[1];
+  if (!tsid) {
+    throw new Error(`Invalid comment ID format: ${input.commentId}`);
+  }
+  const signerKey = await signer.getPublicKey();
+  cleanContentOfUndefined(input.content);
+  const trimmedContent = trimTrailingEmptyBlocks(input.content);
+  const comment = {
+    type: "Comment",
+    id: tsid,
+    body: blocksToPublishable(trimmedContent),
+    space: new Uint8Array(base58btc3.decode(input.targetAccount)),
+    path: input.targetPath,
+    version: input.targetVersion.split(".").map((v) => CID3.parse(v)),
+    signer: new Uint8Array(signerKey),
+    ts: BigInt(Date.now()),
+    sig: new Uint8Array(64)
+  };
+  if (input.replyParentVersion) comment.replyParent = CID3.parse(input.replyParentVersion);
+  if (input.rootReplyCommentVersion) comment.threadRoot = CID3.parse(input.rootReplyCommentVersion);
+  if (input.visibility) comment.visibility = input.visibility;
+  comment.sig = await signObject(signer, comment);
+  const encoded = cborEncode6(comment);
+  return toPublishInput(encoded, []);
+}
 async function commentRecordIdFromBlob(blobData) {
   const decoded = cborDecode2(blobData);
   if (decoded.type !== "Comment") {
@@ -2517,6 +2547,37 @@ function parseMarkdown(markdown) {
   }
   return { tree: rootNodes, metadata };
 }
+function markdownBlockNodesToHMBlockNodes(nodes) {
+  return nodes.map((node) => {
+    const { block } = node;
+    const attributes = {};
+    if (block.childrenType !== void 0) {
+      attributes.childrenType = block.childrenType;
+    }
+    if (block.language !== void 0) {
+      attributes.language = block.language;
+    }
+    const hmBlock = {
+      type: block.type,
+      id: block.id,
+      text: block.text,
+      annotations: block.annotations.map((a) => ({
+        type: a.type,
+        starts: a.starts,
+        ends: a.ends,
+        ...a.link !== void 0 ? { link: a.link } : {}
+      })),
+      attributes
+    };
+    if (block.link !== void 0) {
+      hmBlock.link = block.link;
+    }
+    return {
+      block: hmBlock,
+      children: node.children.length > 0 ? markdownBlockNodesToHMBlockNodes(node.children) : void 0
+    };
+  });
+}
 function flattenToOperations(tree, parentId = "") {
   const ops = [];
   const blockIds = [];
@@ -2777,6 +2838,23 @@ function formatMediaUrl(url, useGateway) {
 function indent(depth) {
   return "  ".repeat(depth);
 }
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function draftFilename(slug, id) {
+  if (!slug) return `${id}.md`;
+  return `${slug}_${id}.md`;
+}
+function parseDraftFilename(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  const ext = lastDot >= 0 ? filename.slice(lastDot) : "";
+  const base = lastDot >= 0 ? filename.slice(0, lastDot) : filename;
+  const lastUnderscore = base.lastIndexOf("_");
+  if (lastUnderscore >= 0 && ext === ".md") {
+    return { id: base.slice(lastUnderscore + 1), ext };
+  }
+  return { id: base, ext };
+}
 
 // src/block-diff.ts
 function createBlocksMap(nodes, parentId = "") {
@@ -3140,12 +3218,640 @@ function generateBlockId5() {
   }
   return id;
 }
+
+// src/unicode.ts
+var AnnotationSet = class {
+  annotations;
+  constructor() {
+    this.annotations = /* @__PURE__ */ new Map();
+  }
+  addSpan(type, attributes, start, end) {
+    const id = this._annotationId(type, attributes);
+    let annotation = this.annotations.get(id);
+    if (!annotation) {
+      const annAttrs = attributes ? { ...attributes } : {};
+      let link;
+      if (type == "Link" || type == "Embed") {
+        link = attributes == null ? void 0 : attributes.link;
+        delete annAttrs.link;
+      }
+      annotation = {
+        type,
+        attributes: annAttrs,
+        link: link || "",
+        starts: [],
+        ends: []
+      };
+      this.annotations.set(id, annotation);
+    }
+    addSpanToAnnotation(annotation, start, end);
+  }
+  _annotationId(type, attributes) {
+    if (attributes) {
+      if (attributes.link) {
+        return `${type}-${attributes.link}`;
+      }
+      if (attributes.href) {
+        return `${type}-${attributes.href}`;
+      }
+    }
+    return type;
+  }
+  list() {
+    const keys = Array.from(this.annotations.keys()).sort();
+    let out = new Array(keys.length);
+    for (let i in keys) {
+      const annotation = this.annotations.get(keys[i]);
+      if (annotation) out[i] = annotation;
+    }
+    out = out.sort((a, b) => {
+      let startA = a.starts[0];
+      let startB = b.starts[0];
+      return (startA || 0) - (startB || 0);
+    });
+    return out;
+  }
+};
+function addSpanToAnnotation(annotation, start, end) {
+  if (!annotation.starts) {
+    annotation.starts = [];
+  }
+  if (!annotation.ends) {
+    annotation.ends = [];
+  }
+  if (annotation.starts.length == 0) {
+    pushSpanToAnnotation(annotation, start, end);
+    return;
+  }
+  const lastIdx = annotation.starts.length - 1;
+  if (annotation.ends[lastIdx] == start) {
+    annotation.ends[lastIdx] = end;
+    return;
+  }
+  pushSpanToAnnotation(annotation, start, end);
+}
+function pushSpanToAnnotation(annotation, start, end) {
+  annotation.starts.push(start);
+  annotation.ends.push(end);
+}
+
+// src/editorblock-to-hmblock.ts
+function toHMBlockType(editorBlockType) {
+  if (editorBlockType === "heading") return "Heading";
+  if (editorBlockType === "paragraph") return "Paragraph";
+  if (editorBlockType === "code-block") return "Code";
+  if (editorBlockType === "math") return "Math";
+  if (editorBlockType === "image") return "Image";
+  if (editorBlockType === "video") return "Video";
+  if (editorBlockType === "file") return "File";
+  if (editorBlockType === "button") return "Button";
+  if (editorBlockType === "embed") return "Embed";
+  if (editorBlockType === "web-embed") return "WebEmbed";
+  if (editorBlockType === "query") return "Query";
+  return void 0;
+}
+function editorBlockToHMBlock(editorBlock) {
+  var _a, _b, _c, _d, _e, _f;
+  const blockType = toHMBlockType(editorBlock.type);
+  if (!blockType) throw new Error("Unsupported block type " + editorBlock.type);
+  let block = {
+    id: editorBlock.id,
+    type: blockType,
+    attributes: {},
+    text: "",
+    annotations: []
+  };
+  let leaves = flattenLeaves(editorBlock.content);
+  if (editorBlock.props.childrenType == "Group") {
+    block.attributes.childrenType = "Group";
+  } else if (editorBlock.props.childrenType == "Unordered") {
+    block.attributes.childrenType = "Unordered";
+  } else if (editorBlock.props.childrenType == "Ordered") {
+    block.attributes.childrenType = "Ordered";
+  } else if (editorBlock.props.childrenType == "Blockquote") {
+    block.attributes.childrenType = "Blockquote";
+  } else if (editorBlock.props.childrenType == "Grid") {
+    block.attributes.childrenType = "Grid";
+    if (editorBlock.props.columnCount) {
+      block.attributes.columnCount = Number(editorBlock.props.columnCount);
+    }
+  }
+  const annotations = new AnnotationSet();
+  let pos = 0;
+  for (let leaf of leaves) {
+    const start = pos;
+    const charCount = codePointLength(leaf.text);
+    const end = start + charCount;
+    if ((_a = leaf.styles) == null ? void 0 : _a.bold) {
+      annotations.addSpan("Bold", null, start, end);
+    }
+    if ((_b = leaf.styles) == null ? void 0 : _b.italic) {
+      annotations.addSpan("Italic", null, start, end);
+    }
+    if ((_c = leaf.styles) == null ? void 0 : _c.underline) {
+      annotations.addSpan("Underline", null, start, end);
+    }
+    if ((_d = leaf.styles) == null ? void 0 : _d.strike) {
+      annotations.addSpan("Strike", null, start, end);
+    }
+    if ((_e = leaf.styles) == null ? void 0 : _e.code) {
+      annotations.addSpan("Code", null, start, end);
+    }
+    if ((_f = leaf.styles) == null ? void 0 : _f.math) {
+      annotations.addSpan("Math", null, start, end);
+    }
+    if (leaf.type == "inline-embed") {
+      annotations.addSpan("Embed", { link: leaf.link }, start, end);
+    }
+    if (leaf.type == "link") {
+      annotations.addSpan("Link", { link: leaf.href }, start, end);
+    }
+    block.text += leaf.text;
+    pos += charCount;
+  }
+  let outAnnotations = annotations.list();
+  if (outAnnotations) {
+    block.annotations = outAnnotations;
+  }
+  const blockCode = block.type === "Code" ? block : void 0;
+  if (blockCode && editorBlock.type == "code-block") {
+    blockCode.attributes.language = editorBlock.props.language;
+  }
+  const blockImage = block.type === "Image" ? block : void 0;
+  if (blockImage && editorBlock.type == "image") {
+    if (editorBlock.props.url && !editorBlock.props.mediaRef) {
+      blockImage.link = editorBlock.props.url;
+    } else if (editorBlock.props.mediaRef) {
+      blockImage.link = "";
+    } else if (editorBlock.props.displaySrc) {
+      blockImage.link = editorBlock.props.displaySrc;
+    } else if (editorBlock.props.src) {
+      blockImage.link = editorBlock.props.src;
+    } else {
+      blockImage.link = "";
+    }
+    const width = toNumber(editorBlock.props.width);
+    if (width) {
+      blockImage.attributes.width = width;
+    }
+  }
+  const blockVideo = block.type === "Video" ? block : void 0;
+  if (blockVideo && editorBlock.type == "video") {
+    blockVideo.text = "";
+    if (editorBlock.props.url && !editorBlock.props.mediaRef) {
+      blockVideo.link = editorBlock.props.url;
+    } else if (editorBlock.props.mediaRef) {
+      blockVideo.link = "";
+    }
+    const width = toNumber(editorBlock.props.width);
+    if (width) blockVideo.attributes.width = width;
+    if (editorBlock.props.name) {
+      blockVideo.attributes.name = editorBlock.props.name;
+    }
+  }
+  const blockFile = block.type === "File" ? block : void 0;
+  if (blockFile && editorBlock.type == "file") {
+    if (editorBlock.props.url && !editorBlock.props.mediaRef) {
+      blockFile.link = editorBlock.props.url;
+    } else if (editorBlock.props.mediaRef) {
+      blockFile.link = "";
+    }
+    if (editorBlock.props.name) blockFile.attributes.name = editorBlock.props.name;
+    const size = toNumber(editorBlock.props.size);
+    if (size) blockFile.attributes.size = size;
+  }
+  const blockButton = block.type === "Button" ? block : void 0;
+  if (blockButton && editorBlock.type == "button") {
+    if (editorBlock.props.url) blockButton.link = editorBlock.props.url;
+    if (editorBlock.props.name) blockButton.attributes.name = editorBlock.props.name;
+    if (editorBlock.props.alignment)
+      blockButton.attributes.alignment = HMBlockButtonAlignmentSchema.parse(editorBlock.props.alignment);
+  }
+  const blockWebEmbed = block.type === "WebEmbed" ? block : void 0;
+  if (blockWebEmbed && editorBlock.type == "web-embed" && editorBlock.props.url) {
+    blockWebEmbed.link = editorBlock.props.url;
+  }
+  const blockEmbed = block.type === "Embed" ? block : void 0;
+  if (blockEmbed && editorBlock.type == "embed") {
+    block.text = "";
+    if (editorBlock.props.url) blockEmbed.link = editorBlock.props.url;
+    if (editorBlock.props.view) blockEmbed.attributes.view = editorBlock.props.view;
+  }
+  const blockQuery = block.type === "Query" ? block : void 0;
+  if (blockQuery && editorBlock.type == "query") {
+    blockQuery.attributes.style = editorBlock.props.style;
+    blockQuery.attributes.columnCount = Number(editorBlock.props.columnCount);
+    const query = {
+      includes: [],
+      sort: []
+    };
+    if (editorBlock.props.queryIncludes) query.includes = JSON.parse(editorBlock.props.queryIncludes);
+    if (editorBlock.props.querySort) query.sort = JSON.parse(editorBlock.props.querySort);
+    if (editorBlock.props.queryLimit) query.limit = Number(editorBlock.props.queryLimit);
+    blockQuery.attributes.query = query;
+    blockQuery.attributes.banner = editorBlock.props.banner == "true";
+  }
+  const blockParse = HMBlockSchema.safeParse(block);
+  if (blockParse.success) {
+    return blockParse.data;
+  }
+  const failedParse = blockParse;
+  console.error("Failed to validate block for writing", block, failedParse.error);
+  throw new Error("Failed to validate block for writing " + JSON.stringify(failedParse.error));
+}
+function editorBlocksToHMBlockNodes(editorBlocks) {
+  return editorBlocks.map((block) => {
+    var _a, _b;
+    try {
+      return {
+        block: editorBlockToHMBlock(block),
+        children: ((_a = block.children) == null ? void 0 : _a.length) ? editorBlocksToHMBlockNodes(block.children) : void 0
+      };
+    } catch {
+      return {
+        block: {
+          id: block.id || "unknown",
+          type: "Paragraph",
+          text: `[Unsupported block type: ${block.type}]`,
+          annotations: [],
+          attributes: {}
+        },
+        children: ((_b = block.children) == null ? void 0 : _b.length) ? editorBlocksToHMBlockNodes(block.children) : void 0
+      };
+    }
+  }).filter(Boolean);
+}
+function flattenLeaves(content) {
+  let result = [];
+  for (let i = 0; i < content.length; i++) {
+    const leaf = content[i];
+    if (!leaf) continue;
+    if (leaf.type == "link") {
+      let nestedLeaves = flattenLeaves(leaf.content).map(
+        (l) => ({
+          ...l,
+          href: leaf.href,
+          type: "link"
+        })
+      );
+      result.push(...nestedLeaves);
+    }
+    if (leaf.type == "inline-embed") {
+      result.push({
+        ...leaf,
+        text: "\uFFFC",
+        link: leaf.link
+      });
+    }
+    if (leaf.type == "text") {
+      result.push(leaf);
+    }
+  }
+  return result;
+}
+
+// src/hmblock-to-editorblock.ts
+function toEditorBlockType(hmBlockType) {
+  if (hmBlockType === "Heading") return "heading";
+  if (hmBlockType === "Paragraph") return "paragraph";
+  if (hmBlockType === "Code") return "code-block";
+  if (hmBlockType === "Math") return "math";
+  if (hmBlockType === "Image") return "image";
+  if (hmBlockType === "Video") return "video";
+  if (hmBlockType === "File") return "file";
+  if (hmBlockType === "Button") return "button";
+  if (hmBlockType === "Embed") return "embed";
+  if (hmBlockType === "WebEmbed") return "web-embed";
+  if (hmBlockType === "Nostr") return "nostr";
+  if (hmBlockType === "Query") return "query";
+  return "unknown";
+}
+function hmBlocksToEditorContent(blocks, opts = { level: 1 }) {
+  const childRecursiveOpts = {
+    level: opts.level || 0
+  };
+  return blocks.map((hmBlock) => {
+    var _a, _b, _c;
+    let res = hmBlock.block ? hmBlockToEditorBlock(hmBlock.block) : null;
+    if (res && ((_a = hmBlock.children) == null ? void 0 : _a.length)) {
+      const childrenType = (_c = ((_b = hmBlock.block) == null ? void 0 : _b.attributes) || {}) == null ? void 0 : _c.childrenType;
+      const validChildrenType = childrenType === "Group" || childrenType === "Ordered" || childrenType === "Unordered" || childrenType === "Blockquote" || childrenType === "Grid" ? childrenType : "Group";
+      res.children = hmBlocksToEditorContent(hmBlock.children, {
+        level: childRecursiveOpts.level ? childRecursiveOpts.level + 1 : 1,
+        childrenType: validChildrenType
+      });
+    }
+    return res;
+  }).filter((block) => block !== null);
+}
+function hmBlockToEditorBlock(block) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const blockType = toEditorBlockType(block.type);
+  if (blockType === "unknown") {
+    return {
+      id: block.id,
+      type: "unknown",
+      content: [],
+      props: {
+        revision: block.revision,
+        originalType: block.type,
+        originalData: JSON.stringify(block)
+      },
+      children: []
+    };
+  }
+  let out = {
+    id: block.id,
+    type: blockType,
+    content: [],
+    props: {
+      revision: block.revision
+    },
+    children: []
+  };
+  const attributes = block.attributes || {};
+  if ("childrenType" in attributes && attributes.childrenType) {
+    const childrenType = attributes.childrenType;
+    if (childrenType === "Group" || childrenType === "Ordered" || childrenType === "Unordered" || childrenType === "Blockquote" || childrenType === "Grid") {
+      ;
+      out.props.childrenType = childrenType;
+    }
+    if (childrenType === "Grid" && attributes.columnCount != null) {
+      ;
+      out.props.columnCount = String(attributes.columnCount);
+    }
+  }
+  if (["code-block", "video", "image", "file", "button", "embed", "web-embed", "math", "nostr"].includes(blockType)) {
+    if (block.link) {
+      ;
+      out.props.url = block.link;
+    }
+    if (blockType == "code-block") {
+      out.type = "code-block";
+    }
+    if (block.attributes) {
+      Object.entries(block.attributes).forEach(([key, value]) => {
+        if (value !== void 0) {
+          if (key == "width" || key == "size") {
+            if (typeof value == "number") {
+              ;
+              out.props[key] = String(value);
+            }
+          } else {
+            ;
+            out.props[key] = value;
+          }
+        }
+      });
+    }
+  }
+  if (block.type === "Query") {
+    const queryProps = out.props;
+    queryProps.style = (_a = block.attributes) == null ? void 0 : _a.style;
+    queryProps.columnCount = String(((_b = block.attributes) == null ? void 0 : _b.columnCount) || "");
+    queryProps.queryIncludes = JSON.stringify(((_d = (_c = block.attributes) == null ? void 0 : _c.query) == null ? void 0 : _d.includes) || []);
+    queryProps.querySort = JSON.stringify(((_f = (_e = block.attributes) == null ? void 0 : _e.query) == null ? void 0 : _f.sort) || {});
+    queryProps.banner = ((_g = block.attributes) == null ? void 0 : _g.banner) ? "true" : "false";
+    queryProps.queryLimit = String(((_i = (_h = block.attributes) == null ? void 0 : _h.query) == null ? void 0 : _i.limit) || "");
+  }
+  const blockText = block.text || "";
+  const leaves = out.content;
+  let leaf = null;
+  let inlineBlockContent = null;
+  let textStart = 0;
+  let i = 0;
+  const stopPoint = block.text ? block.text.length - 1 : 0;
+  let pos = 0;
+  const leafAnnotations = /* @__PURE__ */ new Set();
+  if (blockText == "") {
+    leaves.push({ type: "text", text: blockText, styles: {} });
+    return out;
+  }
+  while (i < blockText.length) {
+    let ul = 1;
+    let annotationsChanged = trackPosAnnotations(pos);
+    let surrogate = isSurrogate(blockText, i);
+    if (surrogate) {
+      ul++;
+      let onlyOneSurrogate = pos + ul;
+      if (onlyOneSurrogate == blockText.length) {
+        if (!leaf) {
+          startLeaf(leafAnnotations);
+        }
+        finishLeaf(textStart, i + 2);
+        if (inlineBlockContent) {
+          const lastLeaf = leaves[leaves.length - 1];
+          if (lastLeaf && !isText(lastLeaf)) {
+          }
+          leaves.push(inlineBlockContent);
+          inlineBlockContent = null;
+        }
+        return out;
+      }
+    }
+    if (stopPoint < 0) {
+      console.warn("STOP IS LESS THAN ZERO", block);
+    }
+    if (i == stopPoint) {
+      if (annotationsChanged) {
+        if (leaf) {
+          finishLeaf(textStart, i);
+        }
+        startLeaf(leafAnnotations);
+      } else {
+        startLeaf(leafAnnotations);
+      }
+      finishLeaf(textStart, i + 1);
+      if (inlineBlockContent) {
+        const lastLeaf = leaves[leaves.length - 1];
+        if (lastLeaf && !isText(lastLeaf)) {
+        }
+        leaves.push(inlineBlockContent);
+        inlineBlockContent = null;
+      }
+      return out;
+    }
+    if (!leaf) {
+      startLeaf(leafAnnotations);
+      advance(ul);
+      continue;
+    }
+    if (annotationsChanged) {
+      finishLeaf(textStart, i);
+      startLeaf(leafAnnotations);
+    }
+    advance(ul);
+    if (i == blockText.length) {
+      finishLeaf(textStart, i);
+      return out;
+    }
+  }
+  throw Error("BUG: should not get here");
+  function advance(codeUnits) {
+    pos++;
+    i += codeUnits;
+  }
+  function startLeaf(posAnnotations) {
+    const newLeaf = {
+      type: "text",
+      text: "",
+      styles: {}
+    };
+    leaf = newLeaf;
+    let linkAnnotation = null;
+    for (const l of Array.from(posAnnotations)) {
+      const annotationData = l;
+      if (annotationData.type === "Link") {
+        linkAnnotation = {
+          type: "Link",
+          href: annotationData.link || ""
+        };
+      }
+      if (annotationData.type === "Embed") {
+        linkAnnotation = {
+          type: "Embed",
+          link: annotationData.link || ""
+        };
+      }
+      if (["Bold", "Italic", "Strike", "Underline", "Code", "Range"].includes(annotationData.type)) {
+        const styleKey = annotationData.type.toLowerCase();
+        newLeaf.styles[styleKey] = true;
+      }
+    }
+    if (linkAnnotation) {
+      if (linkAnnotation.type === "Embed") {
+        leaves.push({
+          type: "inline-embed",
+          styles: {},
+          link: linkAnnotation.link || ""
+        });
+        textStart = i + 1;
+      } else if (inlineBlockContent) {
+        if (linkChangedIdentity(linkAnnotation)) {
+          leaves.push(inlineBlockContent);
+          if (linkAnnotation.type === "Link") {
+            inlineBlockContent = {
+              type: "link",
+              content: [],
+              href: linkAnnotation.href || ""
+            };
+          } else {
+            inlineBlockContent = {
+              type: "inline-embed",
+              styles: {},
+              link: linkAnnotation.link || ""
+            };
+          }
+        }
+      } else {
+        if (linkAnnotation.type === "Link") {
+          inlineBlockContent = {
+            type: "link",
+            content: [],
+            href: linkAnnotation.href || ""
+          };
+        } else {
+          inlineBlockContent = {
+            type: "inline-embed",
+            styles: {},
+            link: linkAnnotation.link || ""
+          };
+        }
+      }
+    } else {
+      if (inlineBlockContent) {
+        leaves.push(inlineBlockContent);
+        inlineBlockContent = null;
+      }
+    }
+  }
+  function linkChangedIdentity(annotation) {
+    if (!inlineBlockContent) return false;
+    let currentLink = inlineBlockContent.link || inlineBlockContent.href;
+    return currentLink != annotation.link && currentLink != annotation.href;
+  }
+  function finishLeaf(low, high) {
+    let newValue = blockText.substring(low, high);
+    if (leaf) leaf.text = newValue;
+    textStart = high;
+    if (inlineBlockContent) {
+      if (leaf && inlineBlockContent.type == "link") {
+        ;
+        inlineBlockContent.content.push(leaf);
+      } else if (inlineBlockContent.type == "inline-embed" && leaf) {
+      } else if (leaf) {
+        const typedLeaf = {
+          type: "text",
+          text: "",
+          styles: leaf.styles
+        };
+        inlineBlockContent.content.push(typedLeaf);
+      }
+    } else {
+      if (leaf && !(leaf.type === "text" && leaf.text === "" && Object.keys(leaf.styles).length === 0)) {
+        leaves.push(leaf);
+      }
+    }
+  }
+  function trackPosAnnotations(pos2) {
+    let annotationsChanged = false;
+    if (!block.annotations) {
+      return false;
+    }
+    const blockAnnotations = block.annotations;
+    blockAnnotations.forEach((l) => {
+      let spanIdx = annotationContains(l, pos2);
+      if (spanIdx === -1) {
+        if (leafAnnotations.delete(l)) {
+          annotationsChanged = true;
+        }
+        return;
+      }
+      if (leafAnnotations.has(l)) {
+        return;
+      }
+      leafAnnotations.add(l);
+      annotationsChanged = true;
+    });
+    return annotationsChanged;
+  }
+}
+function annotationContains(annotation, pos) {
+  let low = 0;
+  let high = annotation.starts.length - 1;
+  let mid = 0;
+  while (low <= high) {
+    mid = Math.floor((low + high) / 2);
+    const endAtMid = annotation.ends[mid];
+    if (endAtMid === void 0) break;
+    if (endAtMid <= pos) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  if (low == annotation.starts.length) {
+    return -1;
+  }
+  const startAtLow = annotation.starts[low];
+  const endAtLow = annotation.ends[low];
+  if (startAtLow !== void 0 && endAtLow !== void 0 && startAtLow <= pos && pos < endAtLow) {
+    return low;
+  }
+  return -1;
+}
+function isText(entry) {
+  return (entry == null ? void 0 : entry.type) && entry.type == "text" && typeof entry.text == "string";
+}
 export {
+  AnnotationSet,
   DEFAULT_GROBID_URL,
   HYPERMEDIA_SCHEME,
   SeedClientError,
   SeedNetworkError,
   SeedValidationError,
+  addSpanToAnnotation,
+  annotationContains,
   autoLinkChildToParent,
   blocksToMarkdown,
   codePointLength,
@@ -3170,6 +3876,9 @@ export {
   deleteContact,
   documentContainsLinkToChild,
   documentHasSelfQuery,
+  draftFilename,
+  editorBlockToHMBlock,
+  editorBlocksToHMBlockNodes,
   embeddedPdfToBlocks,
   emitFrontmatter,
   entityQueryPathToHmIdPath,
@@ -3179,27 +3888,34 @@ export {
   getHMQueryString,
   hasFileLinks,
   hmBlockNodeToBlockNode,
+  hmBlockToEditorBlock,
+  hmBlocksToEditorContent,
   hmIdPathToEntityQueryPath,
   isGrobidAvailable,
   isSurrogate,
+  markdownBlockNodesToHMBlockNodes,
   matchBlockIds,
   packBaseId,
   packHmId,
   parseCustomURL,
+  parseDraftFilename,
   parseFragment,
   parseFrontmatter,
   parseInlineFormatting,
   parseMarkdown,
   pdfToBlocks,
   processFulltextDocument,
+  pushSpanToAnnotation,
   resolveDocumentState,
   resolveFileLinksInBlocks,
   serializeBlockRange,
   shouldAutoLinkParent,
   signDocumentChange,
   signPreparedChange,
+  slugify,
   teiToBlocks,
   trimTrailingEmptyBlocks,
   unpackHmId,
+  updateComment,
   updateContact
 };