@mocanvas/mocanvas 1.0.0 → 4.0.0

package/dist/chunk-OCYJAMXT.js

@@ -0,0 +1,1117 @@
+import { T, ImageShapeCrop, ARROWHEAD_KINDS, ARROW_SHAPE_KINDS, LINE_SPLINE_KINDS, assetIdValidator, createBuiltInShapePropsMigrationIds, createBindingPropsMigrationSequence, createBuiltInBindingPropsMigrationIds, createShapePropsMigrationSequence, DefaultFontStyle, DefaultSizeStyle, DefaultDashStyle, DefaultFillStyle, DefaultLabelColorStyle, DefaultColorStyle, DefaultVerticalAlignStyle, DefaultHorizontalAlignStyle, GeoShapeGeoStyle, richTextToPlainText, createShapeId, BaseBoxShapeUtil, Rectangle2d, getDefaultDisplayValues } from '@mocanvas/editor';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/text/tiptap-extensions.ts
+var ZERO_WIDTH_SPACE = "\u200B";
+function level(node) {
+  const value = node.attrs?.["level"];
+  return typeof value === "number" && value >= 1 && value <= 6 ? Math.floor(value) : 1;
+}
+var RICH_TEXT_NODES = [
+  { name: "paragraph", kind: "node", tag: "p", emptyHtml: ZERO_WIDTH_SPACE },
+  { name: "heading", kind: "node", tag: "h1", tagFor: (node) => `h${level(node)}`, emptyHtml: ZERO_WIDTH_SPACE },
+  { name: "bulletList", kind: "node", tag: "ul" },
+  { name: "orderedList", kind: "node", tag: "ol" },
+  { name: "listItem", kind: "node", tag: "li", emptyHtml: ZERO_WIDTH_SPACE },
+  { name: "blockquote", kind: "node", tag: "blockquote" },
+  { name: "codeBlock", kind: "node", tag: "pre" },
+  { name: "hardBreak", kind: "node", tag: "br", void: true },
+  { name: "horizontalRule", kind: "node", tag: "hr", void: true }
+];
+var RICH_TEXT_MARKS = [
+  { name: "bold", kind: "mark", tag: "strong" },
+  { name: "italic", kind: "mark", tag: "em" },
+  { name: "underline", kind: "mark", tag: "u" },
+  { name: "strike", kind: "mark", tag: "s" },
+  { name: "code", kind: "mark", tag: "code" },
+  { name: "highlight", kind: "mark", tag: "mark" },
+  {
+    name: "link",
+    kind: "mark",
+    tag: "a",
+    attributesFor: (mark) => {
+      const href = mark.attrs?.["href"];
+      if (typeof href !== "string") return null;
+      const trimmed = href.trim();
+      return /^(?:https?:|mailto:|tel:|#|\/|\.{1,2}\/)/i.test(trimmed) ? { href: trimmed, rel: "noopener noreferrer" } : null;
+    }
+  }
+];
+var tipTapDefaultExtensions = [...RICH_TEXT_NODES, ...RICH_TEXT_MARKS];
+var editorFactory = null;
+function registerRichTextEditorFactory(factory) {
+  editorFactory = factory;
+  return () => {
+    if (editorFactory === factory) editorFactory = null;
+  };
+}
+function getRichTextEditorFactory() {
+  return editorFactory;
+}
+async function loadTipTapStarterExtensions() {
+  const moduleId = "@tiptap/starter-kit";
+  let loaded;
+  try {
+    loaded = await import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      moduleId
+    );
+  } catch (cause) {
+    throw new Error("mocanvas: `@tiptap/starter-kit` is an optional peer dependency and is not installed. Run `npm install @tiptap/starter-kit@^3 @tiptap/core@^3 @tiptap/pm@^3`, or use `tipTapDefaultExtensions` instead.", { cause });
+  }
+  const starterKit = loaded.default ?? loaded;
+  return [starterKit];
+}
+function toRichText(text) {
+  const source = typeof text === "string" ? text : "";
+  return {
+    type: "doc",
+    content: source.split("\n").map((line) => line.length === 0 ? { type: "paragraph" } : { type: "paragraph", content: [{ type: "text", text: line }] })
+  };
+}
+function isRichText(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const doc = value;
+  return doc.type === "doc" && (doc.content === void 0 || Array.isArray(doc.content));
+}
+function richTextToText(source) {
+  if (source === null || source === void 0) return "";
+  if (typeof source === "string") return source;
+  return richTextToPlainText(source);
+}
+function asRichText(source) {
+  if (isRichText(source)) return source;
+  return toRichText(typeof source === "string" ? source : "");
+}
+function richTextEquals(a, b) {
+  if (a === b) return true;
+  return JSON.stringify(asRichText(a)) === JSON.stringify(asRichText(b));
+}
+function applyPlainTextToRichText(previous, nextText) {
+  const doc = asRichText(previous);
+  if (richTextToText(doc) === nextText) return doc;
+  return toRichText(nextText);
+}
+var SAFE_URL = /^(?:https?:|mailto:|tel:|#|\/|\.{1,2}\/)/i;
+var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (c) => ESCAPES[c]);
+}
+function resolve(extensions) {
+  const nodes = /* @__PURE__ */ new Map();
+  const marks = /* @__PURE__ */ new Map();
+  for (const extension of extensions ?? [...RICH_TEXT_NODES, ...RICH_TEXT_MARKS]) {
+    const kind = extension.kind;
+    if (kind === "node") nodes.set(extension.name, extension);
+    else if (kind === "mark") marks.set(extension.name, extension);
+  }
+  if (nodes.size === 0) for (const node of RICH_TEXT_NODES) nodes.set(node.name, node);
+  if (marks.size === 0) for (const mark of RICH_TEXT_MARKS) marks.set(mark.name, mark);
+  return { nodes, marks };
+}
+function richTextToHtml(source, options = {}) {
+  const { nodes, marks } = resolve(options.extensions);
+  const doc = asRichText(source);
+  return (doc.content ?? []).map((node) => nodeToHtml(node, nodes, marks, options.unknownTypes)).join("");
+}
+function nodeToHtml(node, nodes, marks, unknown) {
+  if (typeof node !== "object" || node === null) return "";
+  if (node.type === "text") return textNodeToHtml(node, marks, unknown);
+  const extension = nodes.get(node.type);
+  if (!extension) {
+    unknown?.add(node.type);
+    return (node.content ?? []).map((child) => nodeToHtml(child, nodes, marks, unknown)).join("");
+  }
+  const tag = extension.tagFor ? extension.tagFor(node) : extension.tag;
+  if (extension.void) return tag === null ? "" : `<${tag}>`;
+  const inner = (node.content ?? []).map((child) => nodeToHtml(child, nodes, marks, unknown)).join("");
+  if (tag === null) return inner;
+  return `<${tag}>${inner.length === 0 && extension.emptyHtml !== void 0 ? extension.emptyHtml : inner}</${tag}>`;
+}
+function textNodeToHtml(node, marks, unknown) {
+  let html = escapeHtml(node.text ?? "");
+  for (const mark of node.marks ?? []) {
+    const extension = marks.get(mark.type);
+    if (!extension) {
+      unknown?.add(mark.type);
+      continue;
+    }
+    const attributes = extension.attributesFor?.(mark) ?? null;
+    if (attributes === null && extension.attributesFor) continue;
+    const rendered = attributes === null ? "" : Object.entries(attributes).map(([k, v]) => ` ${k}="${escapeHtml(v)}"`).join("");
+    html = `<${extension.tag}${rendered}>${html}</${extension.tag}>`;
+  }
+  return html;
+}
+function safeHref(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return SAFE_URL.test(trimmed) ? trimmed : null;
+}
+var PLAIN_STYLE = { bold: false, italic: false, underline: false, strike: false, code: false };
+var BOLD_MARKS = /* @__PURE__ */ new Set(["bold", "strong"]);
+var ITALIC_MARKS = /* @__PURE__ */ new Set(["italic", "em"]);
+var UNDERLINE_MARKS = /* @__PURE__ */ new Set(["underline"]);
+var STRIKE_MARKS = /* @__PURE__ */ new Set(["strike", "strikethrough", "s", "del"]);
+var CODE_MARKS = /* @__PURE__ */ new Set(["code"]);
+function styleOf(marks) {
+  const style = { ...PLAIN_STYLE };
+  for (const mark of marks ?? []) {
+    if (BOLD_MARKS.has(mark.type)) style.bold = true;
+    else if (ITALIC_MARKS.has(mark.type)) style.italic = true;
+    else if (UNDERLINE_MARKS.has(mark.type)) style.underline = true;
+    else if (STRIKE_MARKS.has(mark.type)) style.strike = true;
+    else if (CODE_MARKS.has(mark.type)) style.code = true;
+    else if (mark.type === "link") {
+      const href = safeHref(mark.attrs?.["href"]);
+      if (href !== null) style.href = href;
+    }
+  }
+  return style;
+}
+function richTextToBlocks(source) {
+  if (typeof source === "string") return source.split("\n").map((text) => ({ runs: text.length === 0 ? [] : [{ text, ...PLAIN_STYLE }] }));
+  const doc = asRichText(source);
+  const blocks = [];
+  for (const node of doc.content ?? []) collectBlocks(node, blocks);
+  if (blocks.length === 0) blocks.push({ runs: [] });
+  return blocks;
+}
+function collectBlocks(node, out) {
+  if (typeof node !== "object" || node === null) return;
+  if (node.type === "text" || node.type === "hardBreak") {
+    appendInline(node, out);
+    return;
+  }
+  const children = node.content ?? [];
+  if (children.some((child) => isBlockNode(child))) {
+    for (const child of children) collectBlocks(child, out);
+    return;
+  }
+  out.push({ runs: [] });
+  for (const child of children) appendInline(child, out);
+}
+var BLOCK_NODE_TYPES = /* @__PURE__ */ new Set(["paragraph", "heading", "bulletList", "orderedList", "listItem", "blockquote", "codeBlock", "horizontalRule", "taskList", "taskItem", "table", "tableRow", "tableCell", "tableHeader"]);
+function isBlockNode(node) {
+  if (typeof node !== "object" || node === null) return false;
+  if (node.type === "text" || node.type === "hardBreak") return false;
+  if (Array.isArray(node.marks) && node.marks.length > 0) return false;
+  return BLOCK_NODE_TYPES.has(node.type) || Array.isArray(node.content);
+}
+function appendInline(node, out, inherited) {
+  if (typeof node !== "object" || node === null) return;
+  if (out.length === 0) out.push({ runs: [] });
+  if (node.type === "hardBreak") {
+    out.push({ runs: [] });
+    return;
+  }
+  const style = mergeStyle(inherited, styleOf(node.marks));
+  if (node.type === "text") {
+    const text = node.text ?? "";
+    if (text.length > 0) out[out.length - 1].runs.push({ text, ...style });
+    return;
+  }
+  for (const child of node.content ?? []) appendInline(child, out, style);
+}
+function mergeStyle(base, next) {
+  if (!base) return next;
+  return {
+    bold: base.bold || next.bold,
+    italic: base.italic || next.italic,
+    underline: base.underline || next.underline,
+    strike: base.strike || next.strike,
+    code: base.code || next.code,
+    ...next.href ?? base.href ? { href: next.href ?? base.href } : {}
+  };
+}
+function propsOf(shape) {
+  const props = shape.props;
+  return typeof props === "object" && props !== null && !Array.isArray(props) ? props : {};
+}
+function readString(props, key, fallback) {
+  const value = props?.[key];
+  return typeof value === "string" ? value : fallback;
+}
+function readEnum(props, key, allowed, fallback) {
+  const value = props?.[key];
+  return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+function readStyle(props, key, style, fallback = style.defaultValue) {
+  return readEnum(props, key, style.values, fallback);
+}
+function readNumber(props, key, fallback) {
+  const value = props?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function readBoolean(props, key, fallback) {
+  const value = props?.[key];
+  return typeof value === "boolean" ? value : fallback;
+}
+function readText(props, key = "text") {
+  if (key !== "text") return readString(props, key, "");
+  return richTextToPlainText(readRichText(props));
+}
+function readRichText(props, key = "richText") {
+  const value = props?.[key];
+  const stored = isRichText(value) ? value : null;
+  if (stored !== null && richTextToPlainText(stored).length > 0) return stored;
+  const text = props?.["text"];
+  if (typeof text === "string" && text.length > 0) return toRichText(text);
+  return stored ?? toRichText("");
+}
+function readPoint(props, key, fallback) {
+  const value = props?.[key];
+  if (typeof value !== "object" || value === null) return fallback;
+  return { x: readNumber(value, "x", fallback.x), y: readNumber(value, "y", fallback.y) };
+}
+function readArray(props, key) {
+  const value = props?.[key];
+  return Array.isArray(value) ? value : [];
+}
+function readRecord(props, key) {
+  const value = props?.[key];
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+
+// src/shapes/indicator-paths.ts
+function canBuildPath() {
+  return typeof Path2D !== "undefined";
+}
+function rectPath(w, h, radius = 0) {
+  const path = new Path2D();
+  if (radius > 0 && typeof path.roundRect === "function") {
+    path.roundRect(0, 0, w, h, radius);
+  } else {
+    path.rect(0, 0, w, h);
+  }
+  return path;
+}
+function boxPath(box) {
+  const path = new Path2D();
+  path.rect(box.x, box.y, box.w, box.h);
+  return path;
+}
+function svgPath(d) {
+  return new Path2D(d);
+}
+function polylinePath(points, close = false) {
+  const path = new Path2D();
+  const first = points[0];
+  if (!first) return path;
+  path.moveTo(first.x, first.y);
+  for (let i = 1; i < points.length; i++) {
+    const p = points[i];
+    path.lineTo(p.x, p.y);
+  }
+  if (close) path.closePath();
+  return path;
+}
+var richTextValidator = T.jsonValue.refine((value) => {
+  if (!isRichText(value)) throw new Error(`Expected a rich text document, got ${JSON.stringify(value)}`);
+  return { type: "doc", content: value.content ?? [] };
+});
+function styleValue(style) {
+  return T.unknown.refine((value) => style.validate(value));
+}
+var imageCropValidator = ImageShapeCrop.refine(
+  (crop) => crop.isCircle === void 0 ? { topLeft: crop.topLeft, bottomRight: crop.bottomRight } : { topLeft: crop.topLeft, bottomRight: crop.bottomRight, isCircle: crop.isCircle }
+);
+var pointValidator = T.object({ x: T.number, y: T.number });
+var drawPointValidator = T.object({ x: T.number, y: T.number, z: T.number.optional() });
+var drawSegmentValidator = T.object({
+  type: T.literalEnum("free", "straight"),
+  points: T.arrayOf(drawPointValidator)
+});
+var derivedTextValidator = T.string.optional();
+var geoShapeProps = {
+  geo: GeoShapeGeoStyle,
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  color: DefaultColorStyle,
+  labelColor: DefaultLabelColorStyle,
+  fill: DefaultFillStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  font: DefaultFontStyle,
+  align: DefaultHorizontalAlignStyle,
+  verticalAlign: DefaultVerticalAlignStyle,
+  growY: T.positiveNumber,
+  url: T.linkUrl,
+  richText: richTextValidator,
+  text: derivedTextValidator,
+  scale: T.nonZeroNumber,
+  flipX: T.boolean,
+  flipY: T.boolean
+};
+var arrowShapeProps = {
+  kind: T.literalEnum(...ARROW_SHAPE_KINDS),
+  start: pointValidator,
+  end: pointValidator,
+  bend: T.number,
+  elbowMidPoint: T.number,
+  color: DefaultColorStyle,
+  labelColor: DefaultLabelColorStyle,
+  fill: DefaultFillStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  arrowheadStart: T.literalEnum(...ARROWHEAD_KINDS),
+  arrowheadEnd: T.literalEnum(...ARROWHEAD_KINDS),
+  font: DefaultFontStyle,
+  richText: richTextValidator,
+  text: derivedTextValidator,
+  labelPosition: T.number,
+  scale: T.nonZeroNumber
+};
+var drawShapeProps = {
+  segments: T.arrayOf(drawSegmentValidator),
+  color: DefaultColorStyle,
+  fill: DefaultFillStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  isComplete: T.boolean,
+  isClosed: T.boolean,
+  isPen: T.boolean,
+  scale: T.nonZeroNumber
+};
+var highlightShapeProps = {
+  segments: T.arrayOf(drawSegmentValidator),
+  color: DefaultColorStyle,
+  size: DefaultSizeStyle,
+  isComplete: T.boolean,
+  isPen: T.boolean,
+  scale: T.nonZeroNumber
+};
+var lineShapeProps = {
+  color: DefaultColorStyle,
+  dash: DefaultDashStyle,
+  size: DefaultSizeStyle,
+  spline: T.literalEnum(...LINE_SPLINE_KINDS),
+  points: T.dict(T.string, T.object({ id: T.string, index: T.string, x: T.number, y: T.number })),
+  scale: T.nonZeroNumber
+};
+var textShapeProps = {
+  color: DefaultColorStyle,
+  size: DefaultSizeStyle,
+  font: DefaultFontStyle,
+  textAlign: DefaultHorizontalAlignStyle,
+  w: T.nonZeroNumber,
+  richText: richTextValidator,
+  text: derivedTextValidator,
+  scale: T.nonZeroNumber,
+  autoSize: T.boolean
+};
+var noteShapeProps = {
+  color: DefaultColorStyle,
+  labelColor: DefaultLabelColorStyle,
+  size: DefaultSizeStyle,
+  font: DefaultFontStyle,
+  fontSizeAdjustment: T.positiveNumber,
+  align: DefaultHorizontalAlignStyle,
+  verticalAlign: DefaultVerticalAlignStyle,
+  growY: T.positiveNumber,
+  url: T.linkUrl,
+  richText: richTextValidator,
+  text: derivedTextValidator,
+  // Who first edited the label by hand, or `null` while nobody has. Absent on
+  // every note written before attribution existed, so optional as well.
+  textFirstEditedBy: T.string.nullable().optional(),
+  scale: T.nonZeroNumber
+};
+var frameShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  name: T.string,
+  // A frame's colour is per frame: a frame is chrome around other people's
+  // shapes, and recolouring a mixed selection should not repaint the frames it
+  // happens to contain. Hence a style *value*, not a style.
+  color: styleValue(DefaultColorStyle).optional()
+};
+var groupShapeProps = {};
+var imageShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  assetId: assetIdValidator.nullable(),
+  playing: T.boolean,
+  url: T.linkUrl,
+  crop: imageCropValidator.nullable(),
+  flipX: T.boolean,
+  flipY: T.boolean,
+  altText: T.string
+};
+var videoShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  assetId: assetIdValidator.nullable(),
+  time: T.number,
+  playing: T.boolean,
+  url: T.linkUrl,
+  altText: T.string
+};
+var bookmarkShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  assetId: assetIdValidator.nullable(),
+  url: T.linkUrl
+};
+var embedShapeProps = {
+  w: T.nonZeroNumber,
+  h: T.nonZeroNumber,
+  url: T.linkUrl
+};
+var arrowBindingProps = {
+  terminal: T.literalEnum("start", "end"),
+  normalizedAnchor: pointValidator,
+  isExact: T.boolean,
+  isPrecise: T.boolean
+};
+function backfillMigration(type, defaults, options = {}) {
+  const versions = createBuiltInShapePropsMigrationIds(type, { BackfillMissingProps: 1 });
+  return createShapePropsMigrationSequence({
+    sequence: [
+      {
+        id: versions.BackfillMissingProps,
+        up(props) {
+          if (options.richTextFromText && props["richText"] === void 0) {
+            props["richText"] = toRichText(typeof props["text"] === "string" ? props["text"] : "");
+          }
+          for (const [key, value] of Object.entries(defaults)) {
+            if (props[key] === void 0) props[key] = structuredClone(value);
+          }
+        },
+        down() {
+        }
+      }
+    ]
+  });
+}
+var arrowShapeVersions = createBuiltInShapePropsMigrationIds("arrow", {
+  BackfillMissingProps: 1
+});
+var arrowShapeMigrations = backfillMigration(
+  "arrow",
+  { kind: "arc", elbowMidPoint: 0.5, labelPosition: 0.5, scale: 1 },
+  { richTextFromText: true }
+);
+var drawShapeMigrations = backfillMigration("draw", {
+  isComplete: true,
+  isClosed: false,
+  isPen: false,
+  scale: 1
+});
+var highlightShapeMigrations = backfillMigration("highlight", {
+  isComplete: true,
+  isPen: false,
+  scale: 1
+});
+var lineShapeMigrations = backfillMigration("line", { spline: "line", scale: 1 });
+var textShapeMigrations = backfillMigration("text", { autoSize: true, scale: 1 }, { richTextFromText: true });
+var noteShapeMigrations = backfillMigration(
+  "note",
+  { fontSizeAdjustment: 0, growY: 0, url: "", scale: 1 },
+  { richTextFromText: true }
+);
+var frameShapeMigrations = backfillMigration("frame", { name: "" });
+var groupShapeMigrations = backfillMigration("group", {});
+var imageShapeMigrations = backfillMigration("image", {
+  assetId: null,
+  playing: true,
+  url: "",
+  crop: null,
+  flipX: false,
+  flipY: false,
+  altText: ""
+});
+var videoShapeMigrations = backfillMigration("video", {
+  assetId: null,
+  time: 0,
+  playing: true,
+  url: "",
+  altText: ""
+});
+var bookmarkShapeMigrations = backfillMigration("bookmark", { assetId: null, url: "" });
+var embedShapeMigrations = backfillMigration("embed", { url: "" });
+var arrowBindingMigrations = createBindingPropsMigrationSequence({
+  sequence: [
+    {
+      id: createBuiltInBindingPropsMigrationIds("arrow", { Initial: 1 }).Initial,
+      up() {
+      },
+      down() {
+      }
+    }
+  ]
+});
+var BOOKMARK_WIDTH = 300;
+var BOOKMARK_HEIGHT = 320;
+var BOOKMARK_FILL = "#ffffff";
+var BOOKMARK_STROKE = "#e8e9ea";
+var BOOKMARK_STROKE_WIDTH = 1;
+var BOOKMARK_RADIUS = 8;
+var BOOKMARK_BANNER_HEIGHT = 160;
+var BOOKMARK_BANNER_FILL = "#eceff3";
+var BOOKMARK_PADDING = 12;
+var BOOKMARK_GAP = 6;
+var BOOKMARK_TITLE_HEIGHT = 38;
+var BOOKMARK_META_HEIGHT = 16;
+var BOOKMARK_FAVICON_SIZE = 14;
+var BOOKMARK_TITLE_FONT_SIZE = 14;
+var BOOKMARK_TEXT_FONT_SIZE = 12;
+var BOOKMARK_META_FONT_SIZE = 11;
+var BOOKMARK_TITLE_COLOR = "#1d1d1d";
+var BOOKMARK_TEXT_COLOR = "#666666";
+var BOOKMARK_META_COLOR = "#8f8f8f";
+var BOOKMARK_MIN_BODY_HEIGHT = 80;
+function getBookmarkLayout(w, h) {
+  const pad = BOOKMARK_PADDING;
+  const innerW = Math.max(0, w - pad * 2);
+  const bannerH = Math.max(0, Math.min(BOOKMARK_BANNER_HEIGHT, h - BOOKMARK_MIN_BODY_HEIGHT));
+  const metaY = Math.max(bannerH, h - pad - BOOKMARK_META_HEIGHT);
+  const titleY = bannerH + pad;
+  const titleH = Math.max(0, Math.min(BOOKMARK_TITLE_HEIGHT, metaY - BOOKMARK_GAP - titleY));
+  const descY = titleY + titleH + BOOKMARK_GAP;
+  const clamp = (r) => {
+    const x = Math.max(0, Math.min(r.x, w));
+    const y = Math.max(0, Math.min(r.y, h));
+    return { x, y, w: Math.max(0, Math.min(r.w, w - x)), h: Math.max(0, Math.min(r.h, h - y)) };
+  };
+  return {
+    banner: clamp({ x: 0, y: 0, w, h: bannerH }),
+    title: clamp({ x: pad, y: titleY, w: innerW, h: titleH }),
+    description: clamp({ x: pad, y: descY, w: innerW, h: metaY - BOOKMARK_GAP - descY }),
+    favicon: clamp({
+      x: pad,
+      y: metaY + (BOOKMARK_META_HEIGHT - BOOKMARK_FAVICON_SIZE) / 2,
+      w: BOOKMARK_FAVICON_SIZE,
+      h: BOOKMARK_FAVICON_SIZE
+    }),
+    hostname: clamp({
+      x: pad + BOOKMARK_FAVICON_SIZE + BOOKMARK_GAP,
+      y: metaY,
+      w: innerW - BOOKMARK_FAVICON_SIZE - BOOKMARK_GAP,
+      h: BOOKMARK_META_HEIGHT
+    })
+  };
+}
+function getBookmarkHostname(url) {
+  if (!url) return "";
+  try {
+    const host = new URL(url).hostname.toLowerCase();
+    return host.startsWith("www.") ? host.slice(4) : host;
+  } catch {
+    return "";
+  }
+}
+function getBookmarkAsset(editor, shape) {
+  const assetId = readString(propsOf(shape), "assetId", "");
+  if (!assetId) return null;
+  const asset = editor.getAsset(assetId);
+  return asset && asset.type === "bookmark" ? asset : null;
+}
+function getBookmarkCard(editor, shape) {
+  const url = readString(propsOf(shape), "url", "");
+  const asset = getBookmarkAsset(editor, shape);
+  const props = asset ? asset.props : void 0;
+  return {
+    title: readString(props, "title", ""),
+    description: readString(props, "description", ""),
+    image: readString(props, "image", ""),
+    favicon: readString(props, "favicon", ""),
+    hostname: getBookmarkHostname(url) || getBookmarkHostname(readString(props, "src", "") ?? ""),
+    url,
+    hasAsset: asset !== null
+  };
+}
+function readBookmarkBox(shape) {
+  const p = propsOf(shape);
+  return { w: readNumber(p, "w", BOOKMARK_WIDTH), h: readNumber(p, "h", BOOKMARK_HEIGHT) };
+}
+var ELLIPSIS = { overflow: "hidden", textOverflow: "ellipsis" };
+function createEmptyBookmarkShape(editor, url, point) {
+  const centre = point ?? editor.getViewportPageBounds().center;
+  const id = createShapeId();
+  editor.run(() => {
+    editor.markHistoryStoppingPoint("insert bookmark");
+    editor.createShape({
+      id,
+      type: "bookmark",
+      x: centre.x - BOOKMARK_WIDTH / 2,
+      y: centre.y - BOOKMARK_HEIGHT / 2,
+      props: { w: BOOKMARK_WIDTH, h: BOOKMARK_HEIGHT, url, assetId: null }
+    });
+    editor.setSelectedShapes([id]);
+  });
+  return editor.getShape(id);
+}
+var BookmarkShapeUtil = class extends BaseBoxShapeUtil {
+  static type = "bookmark";
+  static props = bookmarkShapeProps;
+  static migrations = bookmarkShapeMigrations;
+  getDefaultProps() {
+    return { w: BOOKMARK_WIDTH, h: BOOKMARK_HEIGHT, assetId: null, url: "" };
+  }
+  getGeometry(shape) {
+    const { w, h } = readBookmarkBox(shape);
+    return new Rectangle2d({ width: Math.max(1, w), height: Math.max(1, h), isFilled: true });
+  }
+  /**
+   * The card is html — a banner image over wrapped, ellipsised text — which no
+   * single textured quad can stand in for, so the shape always renders through
+   * the DOM overlay.
+   */
+  getRenderStyle(_shape) {
+    return null;
+  }
+  component(shape) {
+    const { w, h } = readBookmarkBox(shape);
+    const card = getBookmarkCard(this.editor, shape);
+    const layout = getBookmarkLayout(w, h);
+    const isEditing = this.editor.getEditingShapeId() === shape.id;
+    const frame = {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: w,
+      height: h,
+      boxSizing: "border-box",
+      overflow: "hidden",
+      borderRadius: BOOKMARK_RADIUS,
+      background: BOOKMARK_FILL,
+      border: `${BOOKMARK_STROKE_WIDTH}px solid ${BOOKMARK_STROKE}`,
+      fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif',
+      /*
+       * The canvas owns the pointer: a card is a shape you drag and select,
+       * not a link you click. The url is still in the DOM as an `<a>` so
+       * assistive tech can read and follow it, but it only takes the pointer
+       * while the shape is being edited.
+       */
+      pointerEvents: isEditing ? "auto" : "none",
+      userSelect: "none"
+    };
+    return /* @__PURE__ */ jsx(
+      "a",
+      {
+        href: card.url || void 0,
+        target: "_blank",
+        rel: "noreferrer noopener",
+        draggable: false,
+        "aria-label": card.title || card.hostname || card.url || "bookmark",
+        tabIndex: isEditing ? 0 : -1,
+        style: { ...frame, display: "block", color: "inherit", textDecoration: "none" },
+        children: card.hasAsset ? this.renderCard(card, layout) : this.renderPlaceholder(card, layout)
+      }
+    );
+  }
+  /** The scraped card: banner, title, description, favicon and host. */
+  renderCard(card, layout) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("div", { style: { position: "absolute", ...layout.banner, background: BOOKMARK_BANNER_FILL, overflow: "hidden" }, children: card.image ? /* @__PURE__ */ jsx(
+        "img",
+        {
+          src: card.image,
+          alt: "",
+          draggable: false,
+          style: { width: "100%", height: "100%", objectFit: "cover", pointerEvents: "none" }
+        }
+      ) : null }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            ...layout.title,
+            ...ELLIPSIS,
+            fontSize: BOOKMARK_TITLE_FONT_SIZE,
+            fontWeight: 600,
+            lineHeight: 1.3,
+            color: BOOKMARK_TITLE_COLOR
+          },
+          children: card.title
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            ...layout.description,
+            ...ELLIPSIS,
+            fontSize: BOOKMARK_TEXT_FONT_SIZE,
+            lineHeight: 1.4,
+            color: BOOKMARK_TEXT_COLOR
+          },
+          children: card.description
+        }
+      ),
+      card.favicon ? /* @__PURE__ */ jsx(
+        "img",
+        {
+          src: card.favicon,
+          alt: "",
+          draggable: false,
+          style: { position: "absolute", ...layout.favicon, objectFit: "contain", pointerEvents: "none" }
+        }
+      ) : null,
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            ...layout.hostname,
+            ...ELLIPSIS,
+            whiteSpace: "nowrap",
+            fontSize: BOOKMARK_META_FONT_SIZE,
+            lineHeight: `${BOOKMARK_META_HEIGHT}px`,
+            color: BOOKMARK_META_COLOR
+          },
+          children: card.hostname
+        }
+      )
+    ] });
+  }
+  /** No asset: an empty banner and the host, so the shape still reads as a link to somewhere. */
+  renderPlaceholder(card, layout) {
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("div", { style: { position: "absolute", ...layout.banner, background: BOOKMARK_BANNER_FILL } }),
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            position: "absolute",
+            ...layout.title,
+            ...ELLIPSIS,
+            fontSize: BOOKMARK_TITLE_FONT_SIZE,
+            lineHeight: 1.3,
+            color: BOOKMARK_META_COLOR
+          },
+          children: card.hostname || card.url
+        }
+      )
+    ] });
+  }
+  getIndicatorPath(shape) {
+    const { w, h } = readBookmarkBox(shape);
+    return rectPath(w, h, BOOKMARK_RADIUS);
+  }
+};
+var EMBED_WIDTH = 720;
+var EMBED_HEIGHT = 500;
+var EMBED_PLACEHOLDER_FILL = "#f5f6f8";
+var EMBED_PLACEHOLDER_STROKE = "#9fa8b2";
+var EMBED_PLACEHOLDER_TEXT = "#5f6670";
+var EMBED_PLACEHOLDER_FONT_SIZE = 13;
+var EMBED_PLACEHOLDER_PADDING = 16;
+var EMBED_RADIUS = 6;
+var EMBED_SANDBOX = "allow-scripts allow-same-origin allow-popups";
+function httpsUrl(host, url, opts = {}) {
+  return `https://${host}${url.pathname}${url.search}${opts.hash ? url.hash : ""}`;
+}
+function youTubeId(candidate) {
+  return candidate && /^[A-Za-z0-9_-]{6,20}$/.test(candidate) ? candidate : null;
+}
+var youtube = {
+  type: "youtube",
+  title: "YouTube",
+  hostnames: ["youtube.com", "m.youtube.com", "youtube-nocookie.com", "youtu.be"],
+  toEmbedUrl(url) {
+    const segments = url.pathname.split("/").filter(Boolean);
+    const host = url.hostname.toLowerCase().replace(/^www\./, "");
+    const id = host === "youtu.be" ? youTubeId(segments[0]) : youTubeId(url.searchParams.get("v")) ?? (segments[0] === "embed" || segments[0] === "shorts" || segments[0] === "live" ? youTubeId(segments[1]) : null);
+    return id ? `https://www.youtube-nocookie.com/embed/${id}` : null;
+  }
+};
+var vimeo = {
+  type: "vimeo",
+  title: "Vimeo",
+  hostnames: ["vimeo.com", "player.vimeo.com"],
+  toEmbedUrl(url) {
+    const id = url.pathname.split("/").filter(Boolean).find((s) => /^\d{6,12}$/.test(s));
+    return id ? `https://player.vimeo.com/video/${id}` : null;
+  }
+};
+var codesandbox = {
+  type: "codesandbox",
+  title: "CodeSandbox",
+  hostnames: ["codesandbox.io"],
+  toEmbedUrl(url) {
+    const segments = url.pathname.split("/").filter(Boolean);
+    const id = segments[0] === "p" && segments[1] === "sandbox" ? segments[2] : segments[0] === "s" || segments[0] === "embed" ? segments[1] : null;
+    return id && /^[A-Za-z0-9_-]{3,64}$/.test(id) ? `https://codesandbox.io/embed/${id}` : null;
+  }
+};
+var figma = {
+  type: "figma",
+  title: "Figma",
+  hostnames: ["figma.com"],
+  toEmbedUrl(url) {
+    if (url.pathname === "/embed") return null;
+    const target = `https://www.figma.com${url.pathname}${url.search}`;
+    return `https://www.figma.com/embed?embed_host=mocanvas&url=${encodeURIComponent(target)}`;
+  },
+  // The one built-in whose embed form is not also a valid input to its own
+  // `toEmbedUrl`: wrapping an already-wrapped url would nest it twice.
+  fromEmbedUrl(url) {
+    if (url.pathname !== "/embed") return null;
+    const target = url.searchParams.get("url");
+    if (!target) return null;
+    try {
+      const parsed = new URL(target);
+      return parsed.protocol === "https:" && normalizeHost(parsed.hostname) === "figma.com" ? parsed.href : null;
+    } catch {
+      return null;
+    }
+  }
+};
+var googleMaps = {
+  type: "google-maps",
+  title: "Google Maps",
+  hostnames: ["google.com", "maps.google.com"],
+  toEmbedUrl(url) {
+    if (!url.pathname.startsWith("/maps")) return null;
+    if (url.pathname.startsWith("/maps/embed")) return httpsUrl("www.google.com", url);
+    const params = new URLSearchParams(url.search);
+    params.set("output", "embed");
+    return `https://www.google.com/maps?${params.toString()}`;
+  }
+};
+var excalidraw = {
+  type: "excalidraw",
+  title: "Excalidraw",
+  hostnames: ["excalidraw.com"],
+  // The scene lives in the fragment (`#json=`, `#room=`), so it has to survive.
+  toEmbedUrl: (url) => httpsUrl("excalidraw.com", url, { hash: true })
+};
+var DEFAULT_EMBED_DEFINITIONS = [youtube, vimeo, codesandbox, figma, googleMaps, excalidraw];
+var embedDefinitions = [...DEFAULT_EMBED_DEFINITIONS];
+var EMPTY_EMBED_CONFIG = Object.freeze({});
+function normalizeHost(hostname) {
+  const host = hostname.toLowerCase();
+  return host.startsWith("www.") ? host.slice(4) : host;
+}
+function getEmbedDefinition(url, definitions = embedDefinitions, config = EMPTY_EMBED_CONFIG) {
+  if (typeof url !== "string" || url.length === 0) return null;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+  const host = normalizeHost(parsed.hostname);
+  for (const definition of definitions) {
+    if (!definition.hostnames.some((h) => normalizeHost(h) === host)) continue;
+    const embedUrl = definition.toEmbedUrl(parsed, config[definition.type]);
+    if (embedUrl && embedUrl.startsWith("https://")) return { definition, embedUrl };
+    return null;
+  }
+  return null;
+}
+function getEmbedInfo(definitions, url, config = EMPTY_EMBED_CONFIG) {
+  const match = getEmbedDefinition(url, definitions, config);
+  if (match !== null) return { definition: match.definition, url, embedUrl: match.embedUrl };
+  if (typeof url !== "string" || url.length === 0) return void 0;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return void 0;
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return void 0;
+  const host = normalizeHost(parsed.hostname);
+  for (const definition of definitions) {
+    if (definition.fromEmbedUrl === void 0) continue;
+    if (!definition.hostnames.some((h) => normalizeHost(h) === host)) continue;
+    let pageUrl;
+    try {
+      pageUrl = definition.fromEmbedUrl(parsed);
+    } catch {
+      pageUrl = null;
+    }
+    if (!pageUrl) continue;
+    return { definition, url: pageUrl, embedUrl: parsed.href };
+  }
+  return void 0;
+}
+function readEmbedBox(shape) {
+  const p = propsOf(shape);
+  return { w: readNumber(p, "w", EMBED_WIDTH), h: readNumber(p, "h", EMBED_HEIGHT) };
+}
+function getEmbedDisplayValues(editor, shape, theme, colorMode) {
+  return {
+    ...getDefaultDisplayValues(editor, shape, theme, colorMode),
+    placeholderFill: EMBED_PLACEHOLDER_FILL,
+    placeholderStroke: EMBED_PLACEHOLDER_STROKE,
+    placeholderTextColor: EMBED_PLACEHOLDER_TEXT,
+    cornerRadius: EMBED_RADIUS
+  };
+}
+var EMBED_SHAPE_PERMISSION_NAMES = [
+  "accelerometer",
+  "autoplay",
+  "camera",
+  "clipboard-write",
+  "encrypted-media",
+  "fullscreen",
+  "geolocation",
+  "gyroscope",
+  "microphone",
+  "picture-in-picture"
+];
+var unknownEmbedShapePermissionOverrides = {};
+function embedShapePermissionsToAllow(permissions) {
+  const granted = EMBED_SHAPE_PERMISSION_NAMES.filter((name) => permissions[name] === true);
+  return granted.length === 0 ? void 0 : granted.join("; ");
+}
+var EmbedShapeUtil = class extends BaseBoxShapeUtil {
+  static type = "embed";
+  static props = embedShapeProps;
+  static migrations = embedShapeMigrations;
+  static options = { getDefaultDisplayValues: getEmbedDisplayValues };
+  getDefaultProps() {
+    return { w: EMBED_WIDTH, h: EMBED_HEIGHT, url: "" };
+  }
+  /**
+   * The per-service settings this util was configured with, keyed by
+   * {@link EmbedDefinition.type}.
+   *
+   * Always an object, so a definition can index it without a guard. This is
+   * where an api key belongs: a definition is handed its own entry and never
+   * reaches for `process.env` itself, which would put the secret in every
+   * bundle that imported the definition and make it the same for every editor
+   * on the page.
+   */
+  get embedConfig() {
+    return this.options.embedConfig ?? EMPTY_EMBED_CONFIG;
+  }
+  /** The permit list in force for this util; see {@link EmbedShapeOptions.embedDefinitions}. */
+  getEmbedDefinitions() {
+    return this.options.embedDefinitions ?? embedDefinitions;
+  }
+  /** This shape's permit-list entry and iframe url, or `null` when it has none. */
+  getEmbedMatch(shape) {
+    return getEmbedDefinition(readString(propsOf(shape), "url", ""), this.getEmbedDefinitions(), this.embedConfig);
+  }
+  /**
+   * The width ÷ height this embed's content wants, or `undefined` when nothing
+   * has an opinion about it.
+   *
+   * Public because the app needs the same answer the util uses: a "fit to
+   * content" command, a paste handler placing a new embed, a layout engine
+   * reserving a slot. It comes from the matching definition's
+   * {@link EmbedDefinition.sizeToContentAspectRatio}; a url off the permit
+   * list, or a service with no fixed shape, answers `undefined`.
+   */
+  resolveAspectRatio(shape) {
+    const ratio = this.getEmbedMatch(shape)?.definition.sizeToContentAspectRatio;
+    return typeof ratio === "number" && Number.isFinite(ratio) && ratio > 0 ? ratio : void 0;
+  }
+  getGeometry(shape) {
+    const { w, h } = readEmbedBox(shape);
+    return new Rectangle2d({ width: Math.max(1, w), height: Math.max(1, h), isFilled: true });
+  }
+  /** An iframe is not a quad: embeds always render through the DOM overlay. */
+  getRenderStyle(_shape) {
+    return null;
+  }
+  component(shape) {
+    const { w, h } = readEmbedBox(shape);
+    const url = readString(propsOf(shape), "url", "");
+    const match = this.getEmbedMatch(shape);
+    const box = {
+      position: "absolute",
+      left: 0,
+      top: 0,
+      width: w,
+      height: h,
+      boxSizing: "border-box",
+      overflow: "hidden",
+      borderRadius: EMBED_RADIUS
+    };
+    if (!match) {
+      return /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: {
+            ...box,
+            background: EMBED_PLACEHOLDER_FILL,
+            border: `1px dashed ${EMBED_PLACEHOLDER_STROKE}`,
+            padding: EMBED_PLACEHOLDER_PADDING,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            textAlign: "center",
+            fontFamily: 'system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif',
+            fontSize: EMBED_PLACEHOLDER_FONT_SIZE,
+            color: EMBED_PLACEHOLDER_TEXT,
+            wordBreak: "break-all",
+            pointerEvents: "none",
+            userSelect: "none"
+          },
+          "aria-label": url ? `embed: ${url}` : "embed",
+          children: url || "No embed url"
+        }
+      );
+    }
+    const isEditing = this.editor.getEditingShapeId() === shape.id;
+    return /* @__PURE__ */ jsx("div", { style: box, children: /* @__PURE__ */ jsx(
+      "iframe",
+      {
+        src: match.embedUrl,
+        title: `${match.definition.title} embed`,
+        width: w,
+        height: h,
+        sandbox: EMBED_SANDBOX,
+        referrerPolicy: "strict-origin-when-cross-origin",
+        loading: "lazy",
+        allowFullScreen: true,
+        style: { display: "block", width: "100%", height: "100%", border: 0, pointerEvents: isEditing ? "auto" : "none" }
+      }
+    ) });
+  }
+  getIndicatorPath(shape) {
+    const { w, h } = readEmbedBox(shape);
+    return rectPath(w, h, EMBED_RADIUS);
+  }
+  /**
+   * "Editing" an embed is not typing into it — the shape has no text of its own.
+   * It is the state in which the embedded page takes the pointer, and it is the
+   * state the iframe above waits for.
+   *
+   * Saying no here left that state unreachable, so the frame stayed inert for
+   * good and the embed was a picture of a page rather than a page: a video that
+   * would not play, a map that would not pan. Saying yes gives an embed the same
+   * two-step every canvas uses for something that wants the pointer for itself —
+   * one click selects the shape and its handles, a double click hands the
+   * pointer over, and clicking away takes it back.
+   */
+  canEdit(_shape) {
+    return true;
+  }
+  /**
+   * An embed whose service declared a fixed content shape resizes
+   * proportionally; anything else is a free box.
+   */
+  // SEMANTICS-ASSUMED: tying the lock to `sizeToContentAspectRatio` is the
+  // reading that makes the two features one feature — the ratio is declared
+  // once and both sizing paths honour it — and it is a no-op for every
+  // built-in, none of which declares one.
+  isAspectRatioLocked(shape) {
+    return this.resolveAspectRatio(shape) !== void 0;
+  }
+  /**
+   * A new embed is created at its service's content ratio, keeping the width
+   * it was asked for. Nothing happens for a service with no declared ratio.
+   */
+  onBeforeCreate(next) {
+    const ratio = this.resolveAspectRatio(next);
+    if (ratio === void 0) return;
+    const { w } = readEmbedBox(next);
+    const h = Math.max(1, w / ratio);
+    if (h === readEmbedBox(next).h) return;
+    return { ...next, props: { ...next.props, h } };
+  }
+};
+
+export { BOOKMARK_BANNER_FILL, BOOKMARK_BANNER_HEIGHT, BOOKMARK_FAVICON_SIZE, BOOKMARK_FILL, BOOKMARK_GAP, BOOKMARK_HEIGHT, BOOKMARK_META_COLOR, BOOKMARK_META_FONT_SIZE, BOOKMARK_META_HEIGHT, BOOKMARK_MIN_BODY_HEIGHT, BOOKMARK_PADDING, BOOKMARK_RADIUS, BOOKMARK_STROKE, BOOKMARK_STROKE_WIDTH, BOOKMARK_TEXT_COLOR, BOOKMARK_TEXT_FONT_SIZE, BOOKMARK_TITLE_COLOR, BOOKMARK_TITLE_FONT_SIZE, BOOKMARK_TITLE_HEIGHT, BOOKMARK_WIDTH, BookmarkShapeUtil, DEFAULT_EMBED_DEFINITIONS, EMBED_HEIGHT, EMBED_PLACEHOLDER_FILL, EMBED_PLACEHOLDER_FONT_SIZE, EMBED_PLACEHOLDER_PADDING, EMBED_PLACEHOLDER_STROKE, EMBED_PLACEHOLDER_TEXT, EMBED_RADIUS, EMBED_SANDBOX, EMBED_SHAPE_PERMISSION_NAMES, EMBED_WIDTH, EmbedShapeUtil, RICH_TEXT_MARKS, RICH_TEXT_NODES, applyPlainTextToRichText, arrowBindingMigrations, arrowBindingProps, arrowShapeMigrations, arrowShapeProps, arrowShapeVersions, asRichText, bookmarkShapeMigrations, bookmarkShapeProps, boxPath, canBuildPath, createEmptyBookmarkShape, drawShapeMigrations, drawShapeProps, embedDefinitions, embedShapeMigrations, embedShapePermissionsToAllow, embedShapeProps, escapeHtml, frameShapeMigrations, frameShapeProps, geoShapeProps, getBookmarkAsset, getBookmarkCard, getBookmarkHostname, getBookmarkLayout, getEmbedDefinition, getEmbedDisplayValues, getEmbedInfo, getRichTextEditorFactory, groupShapeMigrations, groupShapeProps, highlightShapeMigrations, highlightShapeProps, imageShapeMigrations, imageShapeProps, isRichText, lineShapeMigrations, lineShapeProps, loadTipTapStarterExtensions, noteShapeMigrations, noteShapeProps, polylinePath, propsOf, readArray, readBoolean, readEnum, readNumber, readPoint, readRecord, readRichText, readString, readStyle, readText, rectPath, registerRichTextEditorFactory, richTextEquals, richTextToBlocks, richTextToHtml, richTextToText, richTextValidator, safeHref, svgPath, textShapeMigrations, textShapeProps, tipTapDefaultExtensions, toRichText, unknownEmbedShapePermissionOverrides, videoShapeMigrations, videoShapeProps };
+//# sourceMappingURL=chunk-OCYJAMXT.js.map
+//# sourceMappingURL=chunk-OCYJAMXT.js.map