@seamlet/astro 0.7.0 → 0.8.1

package/dist/chunk-27XIZEVS.js

@@ -0,0 +1,705 @@
+import {
+  formatFieldPath,
+  normalizedLine,
+  readRichText,
+  resolveFieldPath
+} from "./chunk-ZUJEM3P7.js";
+
+// src/bridge/editor-shortcuts.ts
+function shortcutOf(event) {
+  const hasCommandKey = event.metaKey || event.ctrlKey;
+  if (!hasCommandKey || event.altKey) {
+    return void 0;
+  }
+  switch (event.code) {
+    case "KeyS":
+      return "save";
+    case "KeyZ":
+      return event.shiftKey ? "redo" : "undo";
+    case "KeyY":
+      return "redo";
+    default:
+      return void 0;
+  }
+}
+
+// src/bridge/image-fields.ts
+function imageFieldAt(schema, path) {
+  const target = path === void 0 ? void 0 : resolveFieldPath(schema, path);
+  const isImage = target?.kind === "field" && target.field.kind === "image";
+  return isImage ? { path: target.path, field: target.field } : void 0;
+}
+
+// src/bridge/messages.ts
+var PROTOCOL_VERSION = 2;
+var EDITOR_KEYS = /* @__PURE__ */ new Set([
+  "save",
+  "undo",
+  "redo",
+  "escape"
+]);
+var TEXT_FORMATS = /* @__PURE__ */ new Set([
+  "bold",
+  "italic",
+  "list"
+]);
+var TYPING_OUTCOMES = /* @__PURE__ */ new Set([
+  "kept",
+  "reverted"
+]);
+function readPageMessage(data) {
+  if (!isRecord(data)) return void 0;
+  return isPageMessage(data) ? data : void 0;
+}
+function readEditorMessage(data) {
+  if (!isRecord(data)) return void 0;
+  return isEditorMessage(data) ? data : void 0;
+}
+function isPageMessage(message) {
+  switch (message["type"]) {
+    case "ready":
+      return isNumber(message["protocol"]);
+    case "file-drag-end":
+    case "rendered":
+    case "render-failed":
+      return true;
+    case "layout":
+      return isLayout(message["layout"]);
+    case "hover":
+    case "file-drag":
+      return isOptional(message["path"], isString);
+    case "click":
+      return isOptional(message["target"], isClickTarget);
+    case "link-click":
+      return isString(message["href"]);
+    case "key":
+      return isString(message["key"]) && EDITOR_KEYS.has(message["key"]);
+    case "file-drop":
+      return isString(message["path"]) && message["file"] instanceof File;
+    case "typing-started":
+    case "typing-refused":
+      return isString(message["path"]);
+    case "typed":
+      return isString(message["path"]) && isString(message["text"]);
+    case "rich-typed":
+      return isString(message["path"]) && isRichText(message["text"]);
+    case "typed-selection":
+      return isString(message["path"]) && isOptional(message["selection"], isTypedSelection);
+    case "typing-ended":
+      return isString(message["path"]) && isString(message["outcome"]) && TYPING_OUTCOMES.has(message["outcome"]);
+    default:
+      return false;
+  }
+}
+function isEditorMessage(message) {
+  switch (message["type"]) {
+    case "connect":
+      return isRecord(message["schema"]);
+    case "render":
+      return isRecord(message["content"]);
+    case "start-typing":
+      return isString(message["path"]) && isString(message["text"]) && typeof message["isSingleLine"] === "boolean" && isPoint(message["point"]);
+    case "start-rich-typing":
+      return isString(message["path"]) && isRichText(message["text"]) && typeof message["isInline"] === "boolean" && isPoint(message["point"]);
+    case "format-typed":
+      return isString(message["format"]) && TEXT_FORMATS.has(message["format"]);
+    case "link-typed":
+      return isOptional(message["href"], isString);
+    case "stop-typing":
+      return true;
+    case "scroll-to":
+      return isFieldPath(message["path"]);
+    default:
+      return false;
+  }
+}
+function isLayout(value) {
+  if (!isRecord(value)) return false;
+  const markers = value["markers"];
+  return Array.isArray(markers) && markers.every(isMarkerBox) && isViewport(value["viewport"]) && isOptional(value["link"], isLinkBox);
+}
+function isMarkerBox(value) {
+  return isRecord(value) && isString(value["path"]) && isBox(value["box"]);
+}
+function isLinkBox(value) {
+  return isRecord(value) && isString(value["href"]) && isBox(value["box"]);
+}
+function isClickTarget(value) {
+  return isRecord(value) && isString(value["path"]) && isPoint(value["point"]);
+}
+function isRichText(value) {
+  return readRichText(value) !== void 0;
+}
+function isTypedSelection(value) {
+  return isRecord(value) && isBox(value["box"]) && typeof value["isCollapsed"] === "boolean" && isTextFormats(value["formats"]);
+}
+function isTextFormats(value) {
+  return isRecord(value) && typeof value["isBold"] === "boolean" && typeof value["isItalic"] === "boolean" && typeof value["isList"] === "boolean" && isOptional(value["href"], isString);
+}
+function isBox(value) {
+  return isRecord(value) && isNumber(value["top"]) && isNumber(value["left"]) && isNumber(value["width"]) && isNumber(value["height"]);
+}
+function isViewport(value) {
+  return isRecord(value) && isNumber(value["width"]) && isNumber(value["height"]);
+}
+function isPoint(value) {
+  return isRecord(value) && isNumber(value["x"]) && isNumber(value["y"]);
+}
+function isFieldPath(value) {
+  return Array.isArray(value) && value.every((segment) => isString(segment) || isNumber(segment));
+}
+function isOptional(value, isPresent) {
+  return value === void 0 || isPresent(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/bridge/file-drags.ts
+function carriesFiles(event) {
+  return event.dataTransfer?.types.includes("Files") === true;
+}
+
+// src/bridge/marked-paths.ts
+function closestMarkedPath(path, isMarked) {
+  for (let length = path.length; length > 0; length -= 1) {
+    const candidate = formatFieldPath(path.slice(0, length));
+    if (isMarked(candidate)) return candidate;
+  }
+  return void 0;
+}
+
+// src/bridge/rich-text-edits.ts
+function isCollapsed(selection) {
+  return selection.start.line === selection.end.line && selection.start.offset === selection.end.offset;
+}
+function formatsAt(text, selection) {
+  const lines = flatLinesOf(text);
+  const spans = isCollapsed(selection) ? spansAtCursor(lines, selection.start) : selectedSpans(lines, selection);
+  const hasSpans = spans.length > 0;
+  const firstHref = spans[0]?.href;
+  const isInOneLink = hasSpans && spans.every((span) => span.href === firstHref);
+  const selectedLines = lines.slice(
+    selection.start.line,
+    selection.end.line + 1
+  );
+  return {
+    isBold: hasSpans && spans.every((span) => span.bold === true),
+    isItalic: hasSpans && spans.every((span) => span.italic === true),
+    isList: selectedLines.length > 0 && selectedLines.every((line) => line.kind === "item"),
+    href: isInOneLink ? firstHref : void 0
+  };
+}
+function linkSelectionAt(text, point) {
+  const line = flatLinesOf(text)[point.line];
+  if (line === void 0) return void 0;
+  const bounds = spanBoundsOf(line.spans);
+  const index = bounds.findIndex(
+    (bound) => point.offset >= bound.from && point.offset <= bound.to
+  );
+  const href = line.spans[index]?.href;
+  if (href === void 0) return void 0;
+  const isSameLink = (at) => line.spans[at]?.href === href;
+  let first = index;
+  while (isSameLink(first - 1)) first -= 1;
+  let last = index;
+  while (isSameLink(last + 1)) last += 1;
+  return {
+    start: { line: point.line, offset: bounds[first]?.from ?? 0 },
+    end: { line: point.line, offset: bounds[last]?.to ?? 0 }
+  };
+}
+function toggleMark(text, selection, mark) {
+  const lines = flatLinesOf(text);
+  const selected = selectedSpans(lines, selection);
+  const hasMarkEverywhere = selected.length > 0 && selected.every((span) => span[mark] === true);
+  return withSelectedSpans(
+    lines,
+    selection,
+    (span) => hasMarkEverywhere ? withoutMark(span, mark) : { ...span, [mark]: true }
+  );
+}
+function setLink(text, selection, href) {
+  return withSelectedSpans(
+    flatLinesOf(text),
+    selection,
+    (span) => spanOf(span.text, { ...span, href })
+  );
+}
+function toggleList(text, selection) {
+  const lines = flatLinesOf(text);
+  const isSelected = (index) => index >= selection.start.line && index <= selection.end.line;
+  const isListEverywhere = lines.every(
+    (line, index) => !isSelected(index) || line.kind === "item"
+  );
+  const kind = isListEverywhere ? "paragraph" : "item";
+  const changed = lines.map(
+    (line, index) => isSelected(index) ? { ...line, kind } : line
+  );
+  return blocksOf(changed);
+}
+function flatLinesOf(text) {
+  return text.flatMap(
+    (block) => block.kind === "paragraph" ? [{ kind: "paragraph", spans: block.spans }] : block.items.map((spans) => ({ kind: "item", spans }))
+  );
+}
+function blocksOf(lines) {
+  return lines.reduce((blocks, line) => {
+    const previous = blocks.at(-1);
+    if (line.kind === "paragraph") {
+      return [...blocks, { kind: "paragraph", spans: line.spans }];
+    }
+    if (previous?.kind === "list") {
+      const list = {
+        kind: "list",
+        items: [...previous.items, line.spans]
+      };
+      return [...blocks.slice(0, -1), list];
+    }
+    return [...blocks, { kind: "list", items: [line.spans] }];
+  }, []);
+}
+function selectedSpans(lines, selection) {
+  return lines.flatMap((line, index) => {
+    const range = rangeInLine(line, index, selection);
+    return range === void 0 ? [] : piecesIn(line.spans, range).inside;
+  });
+}
+function spansAtCursor(lines, point) {
+  const spans = lines[point.line]?.spans ?? [];
+  const bounds = spanBoundsOf(spans);
+  const index = bounds.findIndex(
+    (bound) => point.offset > bound.from && point.offset <= bound.to
+  );
+  const span = spans[index === -1 ? 0 : index];
+  return span === void 0 ? [] : [span];
+}
+function spanBoundsOf(spans) {
+  return spans.reduce((bounds, span) => {
+    const from = bounds.at(-1)?.to ?? 0;
+    return [...bounds, { from, to: from + span.text.length }];
+  }, []);
+}
+function withSelectedSpans(lines, selection, change) {
+  const changed = lines.map((line, index) => {
+    const range = rangeInLine(line, index, selection);
+    if (range === void 0) return line;
+    const { before, inside, after } = piecesIn(line.spans, range);
+    const spans = normalizedLine([...before, ...inside.map(change), ...after]);
+    return { ...line, spans };
+  });
+  return blocksOf(changed);
+}
+function rangeInLine(line, index, selection) {
+  const isOutside = index < selection.start.line || index > selection.end.line;
+  if (isOutside) return void 0;
+  const length = lengthOf(line.spans);
+  const from = index === selection.start.line ? selection.start.offset : 0;
+  const to = index === selection.end.line ? selection.end.offset : length;
+  const range = { from: clamp(from, length), to: clamp(to, length) };
+  return range.from < range.to ? range : void 0;
+}
+function piecesIn(spans, range) {
+  const pieces = spans.reduce(
+    (state, span) => {
+      const end = state.at + span.text.length;
+      const edges = [range.from, range.to].filter(
+        (edge) => edge > state.at && edge < end
+      );
+      const parts = cutAt(
+        span,
+        edges.map((edge) => edge - state.at)
+      );
+      return { at: end, cut: [...state.cut, ...parts] };
+    },
+    { at: 0, cut: [] }
+  ).cut;
+  return pieces.reduce(
+    (state, piece) => {
+      const end = state.at + piece.text.length;
+      const place = placeOf(state.at, end, range);
+      return { ...state, at: end, [place]: [...state[place], piece] };
+    },
+    { at: 0, before: [], inside: [], after: [] }
+  );
+}
+function placeOf(start, end, range) {
+  if (end <= range.from) return "before";
+  if (start >= range.to) return "after";
+  return "inside";
+}
+function cutAt(span, offsets) {
+  const bounds = [0, ...offsets, span.text.length];
+  return bounds.slice(1).map((end, index) => ({
+    ...span,
+    text: span.text.slice(bounds[index], end)
+  }));
+}
+function withoutMark(span, mark) {
+  return spanOf(span.text, { ...span, [mark]: false });
+}
+function spanOf(text, marks) {
+  return {
+    text,
+    ...marks.bold === true ? { bold: true } : {},
+    ...marks.italic === true ? { italic: true } : {},
+    ...marks.href === void 0 ? {} : { href: marks.href }
+  };
+}
+function lengthOf(spans) {
+  return spans.reduce((length, span) => length + span.text.length, 0);
+}
+function clamp(offset, length) {
+  return Math.min(Math.max(offset, 0), length);
+}
+
+// src/bridge/rich-text-dom.ts
+var LINE_BREAK = "\n";
+var BOLD_TAGS = /* @__PURE__ */ new Set(["b", "strong"]);
+var ITALIC_TAGS = /* @__PURE__ */ new Set(["i", "em"]);
+var BLOCK_TAGS = /* @__PURE__ */ new Set(["p", "div", "h1", "h2", "h3", "h4", "blockquote"]);
+var LIST_TAGS = /* @__PURE__ */ new Set(["ul", "ol"]);
+var LINE_SELECTOR = "p, li";
+var COLLAPSIBLE_WHITESPACE = /[\t\n\f\r ]+/gu;
+var LEADING_WHITESPACE = /^[\t\n\f\r ]+/u;
+var TRAILING_WHITESPACE = /[\t\n\f\r ]+$/u;
+var SPACE = " ";
+function renderRichText(element, text) {
+  const document = element.ownerDocument;
+  const blocks = text.map((block) => blockElement(document, block));
+  element.replaceChildren(...blocks);
+}
+function renderInlineRichText(element, text) {
+  const document = element.ownerDocument;
+  const lines = text.flatMap(
+    (block) => block.kind === "paragraph" ? [block.spans] : block.items
+  );
+  const nodes = lines.flatMap((line, index) => [
+    ...index > 0 ? [document.createElement("br")] : [],
+    ...lineNodes(document, line)
+  ]);
+  element.replaceChildren(...nodes);
+}
+function readRichTextFrom(element) {
+  return blocksOf(readLines(element, []).lines);
+}
+function readSelectionFrom(element) {
+  const selection = element.ownerDocument.getSelection();
+  if (selection === null) return void 0;
+  const anchor = selection.anchorNode;
+  const focus = selection.focusNode;
+  if (anchor === null || focus === null) return void 0;
+  const points = [
+    { node: anchor, offset: selection.anchorOffset },
+    { node: focus, offset: selection.focusOffset }
+  ];
+  const [first, second] = readLines(element, points).points;
+  if (first === void 0 || second === void 0) return void 0;
+  return isBefore(second, first) ? { start: second, end: first } : { start: first, end: second };
+}
+function selectIn(element, selection) {
+  const range = rangeOf(element, selection);
+  if (range === void 0) return;
+  element.ownerDocument.getSelection()?.setBaseAndExtent(
+    range.startContainer,
+    range.startOffset,
+    range.endContainer,
+    range.endOffset
+  );
+}
+function rangeOf(element, selection) {
+  const start = domPointOf(element, selection.start, "forward");
+  const end = domPointOf(element, selection.end, "backward");
+  if (start === void 0 || end === void 0) return void 0;
+  const range = element.ownerDocument.createRange();
+  range.setStart(start.node, start.offset);
+  range.setEnd(end.node, end.offset);
+  return range;
+}
+function insertPlainText(element, words) {
+  const document = element.ownerDocument;
+  const selection = document.getSelection();
+  const range = selection?.rangeCount === 1 ? selection.getRangeAt(0) : void 0;
+  const isInElement = range !== void 0 && element.contains(range.commonAncestorContainer);
+  if (selection === null || !isInElement) return;
+  const inserted = [...wordsNode(document, words).childNodes];
+  const last = inserted.at(-1);
+  range.deleteContents();
+  inserted.reverse().forEach((node) => {
+    range.insertNode(node);
+  });
+  if (last !== void 0) range.setStartAfter(last);
+  range.collapse(true);
+  selection.removeAllRanges();
+  selection.addRange(range);
+}
+function blockElement(document, block) {
+  if (block.kind === "paragraph") {
+    const paragraph = document.createElement("p");
+    paragraph.append(...lineNodes(document, block.spans));
+    return paragraph;
+  }
+  const list = document.createElement("ul");
+  const items = block.items.map((item) => {
+    const listItem = document.createElement("li");
+    listItem.append(...lineNodes(document, item));
+    return listItem;
+  });
+  list.append(...items);
+  return list;
+}
+function lineNodes(document, line) {
+  return line.map((span) => spanNode(document, span));
+}
+function spanNode(document, span) {
+  const words = wordsNode(document, span.text);
+  const italic = span.italic === true ? wrapped(document, "em", words) : words;
+  const bold = span.bold === true ? wrapped(document, "strong", italic) : italic;
+  if (span.href === void 0) return bold;
+  const link = wrapped(document, "a", bold);
+  link.setAttribute("href", span.href);
+  return link;
+}
+function wordsNode(document, text) {
+  const fragment = document.createDocumentFragment();
+  text.split(LINE_BREAK).forEach((line, index) => {
+    if (index > 0) fragment.append(document.createElement("br"));
+    fragment.append(document.createTextNode(line));
+  });
+  return fragment;
+}
+function wrapped(document, tag, content) {
+  const element = document.createElement(tag);
+  element.append(content);
+  return element;
+}
+function readLines(element, points) {
+  const reader = createLineReader(points);
+  element.childNodes.forEach((child, index) => {
+    reader.markChildPoint(element, index);
+    readTopLevel(reader, child);
+  });
+  reader.markChildPoint(element, element.childNodes.length);
+  return reader.finish();
+}
+function readTopLevel(reader, node) {
+  const tag = tagOf(node);
+  if (tag !== void 0 && LIST_TAGS.has(tag)) {
+    [...node.childNodes].forEach((item, index) => {
+      reader.markChildPoint(node, index);
+      if (tagOf(item) !== "li") return;
+      reader.startLine("item");
+      readInline(reader, item, {});
+      reader.endLine();
+    });
+    return;
+  }
+  if (tag !== void 0 && BLOCK_TAGS.has(tag)) {
+    reader.startLine("paragraph");
+    readInline(reader, node, {});
+    reader.endLine();
+    return;
+  }
+  reader.continueLooseLine();
+  readInline(reader, node, {});
+}
+function readInline(reader, node, marks) {
+  if (node.nodeType === node.TEXT_NODE) {
+    const text = (node.textContent ?? "").replace(
+      COLLAPSIBLE_WHITESPACE,
+      SPACE
+    );
+    reader.addText(node, text, marks);
+    return;
+  }
+  const tag = tagOf(node);
+  if (tag === void 0) return;
+  if (tag === "br") {
+    reader.addText(void 0, LINE_BREAK, marks);
+    return;
+  }
+  const inner = marksOf(node, tag, marks);
+  node.childNodes.forEach((child, index) => {
+    reader.markChildPoint(node, index);
+    readInline(reader, child, inner);
+  });
+  reader.markChildPoint(node, node.childNodes.length);
+}
+function createLineReader(points) {
+  const lines = [];
+  const found = points.map(
+    () => void 0
+  );
+  let isLooseOpen = false;
+  const current = () => {
+    const line = lines.at(-1);
+    if (line !== void 0) return line;
+    const first = { kind: "paragraph", spans: [], length: 0 };
+    lines.push(first);
+    return first;
+  };
+  const mark = (isAt, offsetIn) => {
+    points.forEach((point, index) => {
+      if (found[index] !== void 0 || !isAt(point)) return;
+      found[index] = {
+        line: lines.length - 1,
+        offset: current().length + offsetIn(point)
+      };
+    });
+  };
+  return {
+    startLine: (kind) => {
+      lines.push({ kind, spans: [], length: 0 });
+      isLooseOpen = false;
+    },
+    endLine: () => {
+      isLooseOpen = false;
+    },
+    continueLooseLine: () => {
+      if (isLooseOpen) return;
+      lines.push({ kind: "paragraph", spans: [], length: 0 });
+      isLooseOpen = true;
+    },
+    addText: (node, text, marks) => {
+      current();
+      if (node !== void 0)
+        mark(
+          (point) => point.node === node,
+          (point) => point.offset
+        );
+      const line = current();
+      line.spans.push({ text, ...marks });
+      line.length += text.length;
+    },
+    markChildPoint: (parent, index) => {
+      current();
+      mark(
+        (point) => point.node === parent && point.offset === index,
+        () => 0
+      );
+    },
+    finish: () => finishedLines(lines, found)
+  };
+}
+function finishedLines(lines, found) {
+  const trimmed = lines.map((line) => ({
+    kind: line.kind,
+    spans: trimmedLine(line.spans)
+  }));
+  const keptIndexes = trimmed.flatMap(
+    (line, index) => line.spans.length > 0 ? [index] : []
+  );
+  const kept = keptIndexes.flatMap((index) => trimmed[index] ?? []);
+  const points = found.map(
+    (point) => point === void 0 ? void 0 : keptPoint(point, keptIndexes, kept)
+  );
+  return { lines: kept, points };
+}
+function keptPoint(point, keptIndexes, kept) {
+  const sameLine = keptIndexes.indexOf(point.line);
+  if (sameLine !== -1) {
+    const length = lengthOf2(kept[sameLine]?.spans ?? []);
+    return { line: sameLine, offset: Math.min(point.offset, length) };
+  }
+  const nextLine = keptIndexes.findIndex((index) => index > point.line);
+  if (nextLine !== -1) return { line: nextLine, offset: 0 };
+  const lastLine = kept.length - 1;
+  if (lastLine < 0) return void 0;
+  return { line: lastLine, offset: lengthOf2(kept[lastLine]?.spans ?? []) };
+}
+function trimmedLine(spans) {
+  const line = normalizedLine(spans);
+  const last = line.at(-1);
+  const withoutClosingBreak = last !== void 0 && last.text.endsWith(LINE_BREAK) ? [...line.slice(0, -1), { ...last, text: last.text.slice(0, -1) }] : line;
+  const isBlank = withoutClosingBreak.every((span) => span.text.trim() === "");
+  return isBlank ? [] : withoutEdgeWhitespace(withoutClosingBreak);
+}
+function withoutEdgeWhitespace(spans) {
+  const lastIndex = spans.length - 1;
+  const trimmed = spans.map((span, index) => {
+    const withoutLeading = index === 0 ? span.text.replace(LEADING_WHITESPACE, "") : span.text;
+    const text = index === lastIndex ? withoutLeading.replace(TRAILING_WHITESPACE, "") : withoutLeading;
+    return { ...span, text };
+  });
+  return normalizedLine(trimmed);
+}
+function domPointOf(element, point, lean) {
+  const line = lineElementsOf(element)[point.line];
+  if (line === void 0) return void 0;
+  const walker = element.ownerDocument.createTreeWalker(
+    line,
+    NodeFilter.SHOW_ALL
+  );
+  let left = point.offset;
+  for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) {
+    if (node.nodeType === node.TEXT_NODE) {
+      const length = node.textContent?.length ?? 0;
+      const isHere = lean === "forward" ? left < length : left <= length;
+      if (isHere) return { node, offset: left };
+      left -= length;
+    } else if (tagOf(node) === "br") {
+      if (left === 0) return beforeNode(node);
+      left -= 1;
+    }
+  }
+  return { node: line, offset: line.childNodes.length };
+}
+function lineElementsOf(element) {
+  const lines = [...element.querySelectorAll(LINE_SELECTOR)];
+  return lines.length > 0 ? lines : [element];
+}
+function beforeNode(node) {
+  const parent = node.parentNode;
+  if (parent === null) return void 0;
+  return {
+    node: parent,
+    offset: [...parent.childNodes].indexOf(node)
+  };
+}
+function marksOf(element, tag, marks) {
+  const href = tag === "a" ? element.getAttribute("href") : null;
+  return {
+    ...marks,
+    ...BOLD_TAGS.has(tag) ? { bold: true } : {},
+    ...ITALIC_TAGS.has(tag) ? { italic: true } : {},
+    ...href === null ? {} : { href }
+  };
+}
+function tagOf(node) {
+  return node.nodeType === node.ELEMENT_NODE ? node.localName : void 0;
+}
+function isBefore(first, second) {
+  return first.line < second.line || first.line === second.line && first.offset < second.offset;
+}
+function lengthOf2(spans) {
+  return spans.reduce((length, span) => length + span.text.length, 0);
+}
+
+export {
+  shortcutOf,
+  imageFieldAt,
+  PROTOCOL_VERSION,
+  readPageMessage,
+  readEditorMessage,
+  carriesFiles,
+  closestMarkedPath,
+  isCollapsed,
+  formatsAt,
+  linkSelectionAt,
+  toggleMark,
+  setLink,
+  toggleList,
+  renderRichText,
+  renderInlineRichText,
+  readRichTextFrom,
+  readSelectionFrom,
+  selectIn,
+  rangeOf,
+  insertPlainText
+};