chaeditor 0.1.0

package/dist/core.cjs

@@ -0,0 +1,1034 @@
+'use strict';
+
+// src/entities/editor-core/model/editor-attachment-policy.ts
+var MB = 1024 * 1024;
+var EDITOR_ATTACHMENT_MAX_FILE_SIZE = 50 * MB;
+var EDITOR_ATTACHMENT_ALLOWED_EXTENSIONS = [
+  "csv",
+  "doc",
+  "docx",
+  "hwp",
+  "hwpx",
+  "md",
+  "pdf",
+  "ppt",
+  "pptx",
+  "txt",
+  "xls",
+  "xlsx",
+  "zip"
+];
+var EDITOR_ATTACHMENT_ALLOWED_MIME_TYPES = [
+  "application/msword",
+  "application/hwp+zip",
+  "application/pdf",
+  "application/vnd.hancom.hwpx",
+  "application/x-hwp+zip",
+  "application/vnd.ms-excel",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/x-hwp",
+  "application/x-zip-compressed",
+  "application/zip",
+  "text/csv",
+  "text/markdown",
+  "text/plain"
+];
+var EDITOR_ATTACHMENT_FILE_INPUT_ACCEPT = EDITOR_ATTACHMENT_ALLOWED_EXTENSIONS.map(
+  (extension) => `.${extension}`
+).join(",");
+var isAllowedEditorAttachmentExtension = (fileName) => {
+  const baseName = fileName.trim().split("/").pop()?.split("\\").pop()?.trim() ?? "";
+  const lastDotIndex = baseName.lastIndexOf(".");
+  if (lastDotIndex <= 0 || lastDotIndex === baseName.length - 1) return false;
+  const extension = baseName.slice(lastDotIndex + 1).toLowerCase();
+  return EDITOR_ATTACHMENT_ALLOWED_EXTENSIONS.includes(
+    extension
+  );
+};
+var isAllowedEditorAttachmentFile = (file) => {
+  if (!file.name.trim() || file.size <= 0 || file.size > EDITOR_ATTACHMENT_MAX_FILE_SIZE) {
+    return false;
+  }
+  if (!isAllowedEditorAttachmentExtension(file.name)) {
+    return false;
+  }
+  if (!file.type) {
+    return true;
+  }
+  return EDITOR_ATTACHMENT_ALLOWED_MIME_TYPES.includes(
+    file.type
+  );
+};
+
+// src/entities/editor-core/model/editor-video-policy.ts
+var MB2 = 1024 * 1024;
+var EDITOR_VIDEO_MAX_FILE_SIZE = 500 * MB2;
+var EDITOR_VIDEO_ALLOWED_EXTENSIONS = ["m4v", "mov", "mp4", "webm"];
+var EDITOR_VIDEO_ALLOWED_MIME_TYPES = [
+  "video/mp4",
+  "video/quicktime",
+  "video/webm",
+  "video/x-m4v",
+  "application/octet-stream"
+];
+var EDITOR_VIDEO_FILE_INPUT_ACCEPT = [
+  ...EDITOR_VIDEO_ALLOWED_EXTENSIONS.map((extension) => `.${extension}`),
+  ...EDITOR_VIDEO_ALLOWED_MIME_TYPES
+].join(",");
+var isAllowedEditorVideoExtension = (fileName) => {
+  const baseName = fileName.trim().split("/").pop()?.split("\\").pop()?.trim() ?? "";
+  const lastDotIndex = baseName.lastIndexOf(".");
+  if (lastDotIndex <= 0 || lastDotIndex === baseName.length - 1) return false;
+  const extension = baseName.slice(lastDotIndex + 1).toLowerCase();
+  return EDITOR_VIDEO_ALLOWED_EXTENSIONS.includes(
+    extension
+  );
+};
+var isAllowedEditorVideoFile = (file) => {
+  if (!file.name.trim() || file.size <= 0 || file.size > EDITOR_VIDEO_MAX_FILE_SIZE) {
+    return false;
+  }
+  if (!isAllowedEditorVideoExtension(file.name)) {
+    return false;
+  }
+  if (!file.type) {
+    return true;
+  }
+  return EDITOR_VIDEO_ALLOWED_MIME_TYPES.includes(
+    file.type
+  );
+};
+
+// src/shared/lib/markdown/rich-markdown-inline.ts
+var htmlLineBreakPattern = /<br\s*\/?>/gi;
+var htmlHorizontalRulePattern = /<hr\s*\/?>/gi;
+var markdownLineBreakPlaceholder = "__MD_LINE_BREAK__";
+var markdownHorizontalRulePlaceholder = "__MD_HORIZONTAL_RULE__";
+var inlineStyledSpanPattern = /<span style="([^"]+)">([\s\S]*?)<\/span>/g;
+var inlineUnderlinePattern = /<u>([\s\S]*?)<\/u>/g;
+var inlineSpoilerPattern = /\|\|([^|]+?)\|\|/g;
+var inlineMathPattern = /<Math>([\s\S]*?)<\/Math>/g;
+var fenceBoundaryPattern = /^\s*(`{3,}|~{3,})/;
+var getFenceBoundary = (line, activeFence) => {
+  const match = line.match(fenceBoundaryPattern);
+  if (!match) return null;
+  const delimiter = match[1][0];
+  const size = match[1].length;
+  if (!activeFence) {
+    return {
+      delimiter,
+      size
+    };
+  }
+  if (activeFence.delimiter !== delimiter || size < activeFence.size) {
+    return null;
+  }
+  return {
+    delimiter,
+    size
+  };
+};
+var transformMarkdownOutsideCode = (markdown, transform) => {
+  const lines = markdown.split("\n");
+  let activeFence = null;
+  return lines.map((line) => {
+    const fenceBoundary = getFenceBoundary(line, activeFence);
+    if (fenceBoundary) {
+      activeFence = activeFence ? null : fenceBoundary;
+      return line;
+    }
+    if (activeFence) {
+      return line;
+    }
+    let transformedLine = "";
+    for (let cursor = 0; cursor < line.length; ) {
+      if (line[cursor] !== "`") {
+        const nextBacktickIndex = line.indexOf("`", cursor);
+        const proseSegment = line.slice(
+          cursor,
+          nextBacktickIndex === -1 ? line.length : nextBacktickIndex
+        );
+        transformedLine += transform(proseSegment);
+        cursor = nextBacktickIndex === -1 ? line.length : nextBacktickIndex;
+        continue;
+      }
+      let tickCount = 1;
+      while (line[cursor + tickCount] === "`") {
+        tickCount += 1;
+      }
+      const delimiter = "`".repeat(tickCount);
+      const codeStart = cursor;
+      const codeEnd = line.indexOf(delimiter, cursor + tickCount);
+      if (codeEnd === -1) {
+        transformedLine += transform(line.slice(cursor));
+        break;
+      }
+      transformedLine += line.slice(codeStart, codeEnd + tickCount);
+      cursor = codeEnd + tickCount;
+    }
+    return transformedLine;
+  }).join("\n");
+};
+var escapeMarkdownLinkLabel = (value) => value.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+var parseInlineStyle = (style) => {
+  const declarations = style.split(";").map((entry) => entry.trim()).filter(Boolean);
+  const styleMap = /* @__PURE__ */ new Map();
+  declarations.forEach((entry) => {
+    const [property, rawValue] = entry.split(":");
+    if (!property || !rawValue) return;
+    styleMap.set(property.trim().toLowerCase(), rawValue.trim());
+  });
+  const color = styleMap.get("color");
+  const background = styleMap.get("background-color");
+  const colorHex = color?.match(/^#[0-9A-Fa-f]{6}$/)?.[0];
+  const backgroundHex = background?.match(/^#[0-9A-Fa-f]{6}$/)?.[0];
+  return {
+    backgroundHex,
+    colorHex
+  };
+};
+var preprocessMarkdownInlineSyntax = (markdown) => transformMarkdownOutsideCode(
+  markdown,
+  (value) => value.replace(inlineStyledSpanPattern, (_, rawStyle, text) => {
+    const escapedText = escapeMarkdownLinkLabel(text.trim() || "Text");
+    const { backgroundHex, colorHex } = parseInlineStyle(rawStyle);
+    if (backgroundHex && colorHex) {
+      return `[${escapedText}](#md-style:color=${colorHex};background=${backgroundHex})`;
+    }
+    if (backgroundHex) {
+      return `[${escapedText}](#md-bg:${backgroundHex})`;
+    }
+    if (colorHex) {
+      return `[${escapedText}](#md-color:${colorHex})`;
+    }
+    return text;
+  }).replace(inlineUnderlinePattern, (_, text) => {
+    const escapedText = escapeMarkdownLinkLabel(text.trim() || "Text");
+    return `[${escapedText}](#md-underline:)`;
+  }).replace(inlineSpoilerPattern, (_, text) => {
+    const escapedText = escapeMarkdownLinkLabel(text.trim() || "Spoiler");
+    return `[${escapedText}](#md-spoiler:)`;
+  }).replace(inlineMathPattern, (_, formula) => {
+    const normalizedFormula = formula.trim();
+    const encodedFormula = encodeURIComponent(normalizedFormula);
+    const escapedLabel = escapeMarkdownLinkLabel(normalizedFormula || "math");
+    return `[${escapedLabel}](#md-math:${encodedFormula})`;
+  })
+);
+var normalizeMarkdownHtmlAliases = (markdown) => transformMarkdownOutsideCode(
+  markdown,
+  (value) => value.replace(htmlHorizontalRulePattern, markdownHorizontalRulePlaceholder).replace(htmlLineBreakPattern, markdownLineBreakPlaceholder)
+).replace(new RegExp(markdownLineBreakPlaceholder, "g"), "  \n").replace(
+  new RegExp(`(^|
+)${markdownHorizontalRulePlaceholder}(?=
+|$)`, "g"),
+  (_, prefix) => `${prefix}---`
+).replace(new RegExp(markdownHorizontalRulePlaceholder, "g"), "\n---\n");
+
+// src/shared/lib/url/normalize-http-url.ts
+var normalizeHttpUrl = (rawUrl) => {
+  const trimmed = rawUrl?.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+};
+
+// src/entities/editor-core/model/markdown-link.ts
+var createMarkdownLink = (label, url, title) => {
+  const normalizedUrl = normalizeHttpUrl(url);
+  const normalizedLabel = label.trim();
+  if (!normalizedUrl) {
+    return normalizedLabel ? label : url.trim();
+  }
+  const resolvedLabel = normalizedLabel ? label : normalizedUrl;
+  const serializedTitle = title ? ` "${title}"` : "";
+  return `[${resolvedLabel}](${normalizedUrl}${serializedTitle})`;
+};
+var createMarkdownLinkByMode = ({ label, mode, url }) => {
+  if (mode === "embed") {
+    const normalizedUrl = normalizeHttpUrl(url);
+    if (!normalizedUrl) {
+      return label.trim() || url.trim();
+    }
+    return `[embed](${normalizedUrl})`;
+  }
+  if (mode === "preview" || mode === "card") {
+    return createMarkdownLink(label, url, mode);
+  }
+  return createMarkdownLink(label, url);
+};
+var extractLabelAndUrl = (clipboardText) => {
+  const match = clipboardText.trim().match(/^(?<label>.+?)\s+(?<url>https?:\/\/\S+)$/su);
+  const label = match?.groups?.label?.trim() ?? "";
+  const url = normalizeHttpUrl(match?.groups?.url);
+  if (!label || !url) return null;
+  return { label, url };
+};
+var buildEditorLinkInsertion = ({
+  clipboardText,
+  selectedText
+}) => {
+  const normalizedUrl = normalizeHttpUrl(clipboardText);
+  const hasSelectedText = selectedText.trim().length > 0;
+  if (normalizedUrl && hasSelectedText) {
+    return {
+      text: createMarkdownLink(selectedText, normalizedUrl),
+      type: "link"
+    };
+  }
+  if (normalizedUrl) {
+    return {
+      text: createMarkdownLink(normalizedUrl, normalizedUrl),
+      type: "link"
+    };
+  }
+  const extracted = extractLabelAndUrl(clipboardText);
+  if (!extracted) return null;
+  return {
+    text: createMarkdownLink(extracted.label, extracted.url),
+    type: "link"
+  };
+};
+
+// src/shared/lib/markdown/collect-markdown-images.ts
+var markdownImagePattern = /!\[(?<alt>[^\]]*)\]\((?<src>[^)\s]+)(?:\s+(?:"[^"]*"|'[^']*'|\([^)]*\)))?\)/g;
+var galleryStartPattern = /^:::gallery\s*$/;
+var galleryEndPattern = /^:::\s*$/;
+var collectMarkdownImages = (markdown) => {
+  const items = [];
+  let imageIndex = 0;
+  let isInsideGallery = false;
+  for (const line of markdown.split("\n")) {
+    if (galleryStartPattern.test(line)) {
+      isInsideGallery = true;
+      continue;
+    }
+    if (isInsideGallery && galleryEndPattern.test(line)) {
+      isInsideGallery = false;
+      continue;
+    }
+    if (isInsideGallery) continue;
+    for (const matched of line.matchAll(markdownImagePattern)) {
+      const alt = matched.groups?.alt?.trim() ?? "";
+      const src = matched.groups?.src?.trim() ?? "";
+      if (!src) continue;
+      items.push({
+        alt,
+        src,
+        viewerId: `markdown-image-${imageIndex}`
+      });
+      imageIndex += 1;
+    }
+  }
+  return items;
+};
+
+// src/shared/lib/markdown/rich-markdown-segments.ts
+var toggleStartPrefix = ":::toggle ";
+var galleryStartPattern2 = /^:::gallery\s*$/;
+var alignStartPattern = /^:::align (left|center|right)\s*$/;
+var legacyYoutubePattern = /^<YouTube id="([^"]+)" \/>$/;
+var videoPattern = /^<Video provider="([^"]+)"(?: id="([^"]+)")?(?: src="([^"]+)")? \/>$/;
+var attachmentPattern = /^<Attachment href="([^"]+)" name="([^"]+)"(?: size="(\d+)")?(?: type="([^"]+)")? \/>$/;
+var mathPattern = /^<Math(?: block="(true)")?>([\s\S]+?)<\/Math>$/;
+var subtextPrefix = "-# ";
+var fenceBoundaryPattern2 = /^\s*(`{3,}|~{3,})/;
+var decodeHtmlAttributeEntities = (value) => value.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+var getFenceBoundary2 = (line, activeFence) => {
+  const match = line.match(fenceBoundaryPattern2);
+  if (!match) return null;
+  const delimiter = match[1][0];
+  const size = match[1].length;
+  if (!activeFence) {
+    return {
+      delimiter,
+      size
+    };
+  }
+  if (activeFence.delimiter !== delimiter || size < activeFence.size) {
+    return null;
+  }
+  return {
+    delimiter,
+    size
+  };
+};
+var parseToggleTitle = (rawTitle) => {
+  const trimmedTitle = rawTitle.trim();
+  const headingMatch = trimmedTitle.match(/^(#{1,4})(?:\s+(.*))?$/);
+  const fallbackTitle = "Untitled toggle";
+  if (!trimmedTitle) {
+    return {
+      headingLevel: null,
+      title: fallbackTitle
+    };
+  }
+  if (!headingMatch) {
+    return {
+      headingLevel: null,
+      title: trimmedTitle || fallbackTitle
+    };
+  }
+  return {
+    headingLevel: headingMatch[1].length,
+    title: headingMatch[2]?.trim() || fallbackTitle
+  };
+};
+var consumeCustomBlockBody = (lines, startIndex) => {
+  const bodyLines = [];
+  let activeFence = null;
+  let cursor = startIndex;
+  while (cursor < lines.length) {
+    const line = lines[cursor];
+    const fenceBoundary = getFenceBoundary2(line, activeFence);
+    if (fenceBoundary) {
+      bodyLines.push(line);
+      activeFence = activeFence ? null : fenceBoundary;
+      cursor += 1;
+      continue;
+    }
+    if (!activeFence && line === ":::") {
+      break;
+    }
+    bodyLines.push(line);
+    cursor += 1;
+  }
+  return {
+    bodyLines,
+    cursor
+  };
+};
+var parseRichMarkdownSegments = (markdown) => {
+  const lines = markdown.split("\n");
+  const segments = [];
+  const currentMarkdownLines = [];
+  let activeFence = null;
+  const flushMarkdown = () => {
+    if (currentMarkdownLines.length === 0) return;
+    segments.push({
+      markdown: currentMarkdownLines.join("\n"),
+      type: "markdown"
+    });
+    currentMarkdownLines.length = 0;
+  };
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const fenceBoundary = getFenceBoundary2(line, activeFence);
+    if (fenceBoundary) {
+      currentMarkdownLines.push(line);
+      activeFence = activeFence ? null : fenceBoundary;
+      continue;
+    }
+    if (activeFence) {
+      currentMarkdownLines.push(line);
+      continue;
+    }
+    if (line.startsWith(toggleStartPrefix)) {
+      flushMarkdown();
+      const { bodyLines, cursor } = consumeCustomBlockBody(lines, index + 1);
+      const { headingLevel, title } = parseToggleTitle(line.slice(toggleStartPrefix.length));
+      segments.push({
+        content: bodyLines.join("\n"),
+        headingLevel,
+        title,
+        type: "toggle"
+      });
+      index = cursor;
+      continue;
+    }
+    const alignMatch = line.match(alignStartPattern);
+    if (alignMatch) {
+      flushMarkdown();
+      const { bodyLines, cursor } = consumeCustomBlockBody(lines, index + 1);
+      segments.push({
+        align: alignMatch[1],
+        content: bodyLines.join("\n"),
+        type: "align"
+      });
+      index = cursor;
+      continue;
+    }
+    if (galleryStartPattern2.test(line)) {
+      flushMarkdown();
+      const { bodyLines, cursor } = consumeCustomBlockBody(lines, index + 1);
+      segments.push({
+        items: collectMarkdownImages(bodyLines.join("\n")),
+        type: "gallery"
+      });
+      index = cursor;
+      continue;
+    }
+    const videoMatch = line.match(videoPattern);
+    if (videoMatch && (videoMatch[1] === "youtube" || videoMatch[1] === "upload")) {
+      flushMarkdown();
+      segments.push({
+        provider: videoMatch[1],
+        src: videoMatch[3] ? decodeHtmlAttributeEntities(videoMatch[3]) : void 0,
+        type: "video",
+        videoId: videoMatch[2] ? decodeHtmlAttributeEntities(videoMatch[2]) : void 0
+      });
+      continue;
+    }
+    const legacyYoutubeMatch = line.match(legacyYoutubePattern);
+    if (legacyYoutubeMatch) {
+      flushMarkdown();
+      segments.push({
+        provider: "youtube",
+        type: "video",
+        videoId: decodeHtmlAttributeEntities(legacyYoutubeMatch[1])
+      });
+      continue;
+    }
+    const attachmentMatch = line.match(attachmentPattern);
+    if (attachmentMatch) {
+      flushMarkdown();
+      segments.push({
+        contentType: attachmentMatch[4] ? decodeHtmlAttributeEntities(attachmentMatch[4]) : void 0,
+        fileName: decodeHtmlAttributeEntities(attachmentMatch[2]),
+        fileSize: attachmentMatch[3] ? Number(attachmentMatch[3]) : void 0,
+        href: decodeHtmlAttributeEntities(attachmentMatch[1]),
+        type: "attachment"
+      });
+      continue;
+    }
+    const mathMatch = line.match(mathPattern);
+    if (mathMatch) {
+      flushMarkdown();
+      segments.push({
+        formula: mathMatch[2],
+        isBlock: mathMatch[1] === "true",
+        type: "math"
+      });
+      continue;
+    }
+    if (line.startsWith(subtextPrefix)) {
+      flushMarkdown();
+      const subtextLines = [line.slice(subtextPrefix.length)];
+      let cursor = index + 1;
+      while (cursor < lines.length && lines[cursor].startsWith(subtextPrefix)) {
+        subtextLines.push(lines[cursor].slice(subtextPrefix.length));
+        cursor += 1;
+      }
+      segments.push({
+        content: subtextLines.join("\n"),
+        type: "subtext"
+      });
+      index = cursor - 1;
+      continue;
+    }
+    currentMarkdownLines.push(line);
+  }
+  flushMarkdown();
+  return segments;
+};
+
+// src/entities/editor-core/model/video-embed.ts
+var escapeJsxAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var getFirstPathSegment = (pathname) => pathname.split("/").find((segment) => segment.length > 0) ?? null;
+var extractVideoEmbedReference = (value) => {
+  const trimmedValue = value.trim();
+  if (!trimmedValue) return null;
+  try {
+    const url = new URL(trimmedValue);
+    const isYoutubeDomain = url.hostname === "youtube.com" || url.hostname.endsWith(".youtube.com");
+    if (url.hostname === "youtu.be") {
+      const videoId = getFirstPathSegment(url.pathname);
+      return videoId ? {
+        provider: "youtube",
+        videoId
+      } : null;
+    }
+    if (isYoutubeDomain) {
+      if (url.pathname === "/watch") {
+        const videoId = url.searchParams.get("v");
+        return videoId ? {
+          provider: "youtube",
+          videoId
+        } : null;
+      }
+      const [, firstSegment, secondSegment] = url.pathname.split("/");
+      if (firstSegment === "shorts" && secondSegment) {
+        return {
+          provider: "youtube",
+          videoId: secondSegment
+        };
+      }
+      if (firstSegment === "embed" && secondSegment) {
+        return {
+          provider: "youtube",
+          videoId: secondSegment
+        };
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+};
+var extractYoutubeId = (value) => {
+  const reference = extractVideoEmbedReference(value);
+  return reference?.provider === "youtube" ? reference.videoId : null;
+};
+var createVideoEmbedMarkdown = (reference) => {
+  if (reference.provider === "upload") {
+    return `<Video provider="upload" src="${escapeJsxAttribute(reference.src)}" />`;
+  }
+  return `<Video provider="${reference.provider}" id="${escapeJsxAttribute(reference.videoId)}" />`;
+};
+var createYoutubeEmbedMarkdown = (videoId) => createVideoEmbedMarkdown({
+  provider: "youtube",
+  videoId
+});
+var createUploadedVideoEmbedMarkdown = (src) => createVideoEmbedMarkdown({
+  provider: "upload",
+  src
+});
+
+// src/features/edit-markdown/toolbar/contracts/markdown-toolbar-templates.ts
+var escapeMarkdownAltText = (value) => value.replaceAll("]", "\\]");
+var escapeMarkdownLinkDestination = (value) => value.replaceAll("\\", "\\\\").replaceAll("(", "\\(").replaceAll(")", "\\)").replaceAll("<", "%3C").replaceAll(">", "%3E");
+var normalizeMathFormula = (value) => value.trim().replaceAll(/\s*\n+\s*/g, " ");
+var escapeJsxAttribute2 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;");
+var createImageEmbedMarkdown = (altText, url) => `![${escapeMarkdownAltText(altText)}](${escapeMarkdownLinkDestination(url)})`;
+var createImageEmbedMarkdownGroup = (items) => items.map((item) => createImageEmbedMarkdown(item.altText, item.url)).join("\n\n");
+var createImageGalleryMarkdown = (items) => [
+  ":::gallery",
+  ...items.map((item) => createImageEmbedMarkdown(item.altText, item.url)),
+  ":::"
+].join("\n");
+var createAttachmentEmbedMarkdown = ({
+  contentType,
+  fileName,
+  fileSize,
+  url
+}) => `<Attachment href="${escapeJsxAttribute2(url)}" name="${escapeJsxAttribute2(fileName)}" size="${String(fileSize)}" type="${escapeJsxAttribute2(contentType)}" />`;
+var createMathEmbedMarkdown = ({
+  formula,
+  isBlock
+}) => {
+  const normalizedFormula = normalizeMathFormula(formula);
+  if (isBlock) {
+    return `
+<Math block="true">${normalizedFormula}</Math>
+`;
+  }
+  return `<Math>${normalizedFormula}</Math>`;
+};
+var createAlignBlockMarkdown = (align) => {
+  const before = `:::align ${align}
+`;
+  return {
+    cursorOffset: before.length,
+    text: `${before}Text
+:::`
+  };
+};
+var createToggleBlockMarkdown = (level, selectedText) => {
+  const headingPrefix = "#".repeat(level);
+  if (!selectedText) {
+    const prefix = `:::toggle ${headingPrefix} `;
+    return {
+      cursorOffset: prefix.length,
+      text: `${prefix}
+:::`
+    };
+  }
+  return {
+    cursorOffset: `:::toggle ${headingPrefix} `.length + selectedText.length,
+    text: `:::toggle ${headingPrefix} ${selectedText}
+Content
+:::`
+  };
+};
+
+// src/entities/editor-core/model/selection-utils.ts
+var pendingSelectionStartKey = "selectionUtilsPendingStart";
+var pendingSelectionEndKey = "selectionUtilsPendingEnd";
+var setPendingSelection = (textarea, start, end) => {
+  textarea.dataset[pendingSelectionStartKey] = String(start);
+  textarea.dataset[pendingSelectionEndKey] = String(end);
+};
+var getSelectedLineRange = (textarea) => {
+  const { selectionEnd, selectionStart, value } = textarea;
+  const lineStart = selectionStart === 0 ? 0 : value.lastIndexOf("\n", selectionStart - 1) + 1;
+  const nextLineBreakIndex = value.indexOf("\n", selectionEnd);
+  const lineEnd = nextLineBreakIndex === -1 ? value.length : nextLineBreakIndex;
+  return {
+    lineEnd,
+    lineStart,
+    text: value.slice(lineStart, lineEnd)
+  };
+};
+var headingPrefixPattern = /^(#{1,6})\s+/;
+var unorderedListPattern = /^(\s*)([-*])\s+(.*)$/;
+var unorderedListMarkerOnlyPattern = /^(\s*)([-*])\s*$/;
+var orderedListPattern = /^(\s*)(\d+)\.\s+(.*)$/;
+var orderedListMarkerOnlyPattern = /^(\s*)(\d+)\.\s*$/;
+var listItemPattern = /^(\s*)((?:[-*])|(?:\d+\.))\s+/;
+var replaceSelectedLineRange = (textarea, nextBlock, lineStart, lineEnd) => {
+  const nextValue = [
+    textarea.value.slice(0, lineStart),
+    nextBlock,
+    textarea.value.slice(lineEnd)
+  ].join("");
+  setPendingSelection(textarea, lineStart, lineStart + nextBlock.length);
+  return nextValue;
+};
+var wrapSelection = (textarea, before, after, placeholder = "Text") => {
+  const { selectionEnd, selectionStart, value } = textarea;
+  const selectedText = value.slice(selectionStart, selectionEnd);
+  const nextSelectionText = selectedText || placeholder;
+  const nextValue = [
+    value.slice(0, selectionStart),
+    before,
+    nextSelectionText,
+    after,
+    value.slice(selectionEnd)
+  ].join("");
+  const nextStart = selectionStart + before.length;
+  const nextEnd = nextStart + nextSelectionText.length;
+  setPendingSelection(textarea, nextStart, nextEnd);
+  return nextValue;
+};
+var prefixLine = (textarea, prefix) => {
+  const { lineEnd, lineStart, text } = getSelectedLineRange(textarea);
+  const lines = text.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.length > 0);
+  const shouldRemovePrefix = nonEmptyLines.length > 0 && nonEmptyLines.every((line) => line.startsWith(prefix));
+  const nextLines = lines.map((line) => {
+    if (line.length === 0) return line;
+    if (shouldRemovePrefix) {
+      return line.startsWith(prefix) ? line.slice(prefix.length) : line;
+    }
+    return line.startsWith(prefix) ? line : `${prefix}${line}`;
+  });
+  const nextBlock = nextLines.join("\n");
+  const nextValue = [
+    textarea.value.slice(0, lineStart),
+    nextBlock,
+    textarea.value.slice(lineEnd)
+  ].join("");
+  setPendingSelection(textarea, lineStart, lineStart + nextBlock.length);
+  return nextValue;
+};
+var insertTemplate = (textarea, template, cursorOffset = template.length) => {
+  const { selectionEnd, selectionStart, value } = textarea;
+  const nextValue = [value.slice(0, selectionStart), template, value.slice(selectionEnd)].join("");
+  const nextCursor = selectionStart + cursorOffset;
+  setPendingSelection(textarea, nextCursor, nextCursor);
+  return nextValue;
+};
+var restoreCursor = (textarea, start, end) => {
+  const maxIndex = textarea.value.length;
+  const nextStart = Math.max(0, Math.min(start, maxIndex));
+  const nextEnd = Math.max(nextStart, Math.min(end, maxIndex));
+  textarea.setSelectionRange(nextStart, nextEnd);
+  delete textarea.dataset[pendingSelectionStartKey];
+  delete textarea.dataset[pendingSelectionEndKey];
+};
+var focusTextarea = (textarea) => {
+  textarea.focus({ preventScroll: true });
+};
+var getPendingSelection = (textarea) => {
+  const start = Number(textarea.dataset[pendingSelectionStartKey]);
+  const end = Number(textarea.dataset[pendingSelectionEndKey]);
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    return {
+      end: textarea.selectionEnd,
+      start: textarea.selectionStart
+    };
+  }
+  return { end, start };
+};
+var applyTextareaTransform = (textarea, onChange, transform) => {
+  const nextValue = transform(textarea);
+  onChange(nextValue);
+  queueMicrotask(() => {
+    const pendingSelection = getPendingSelection(textarea);
+    focusTextarea(textarea);
+    restoreCursor(textarea, pendingSelection.start, pendingSelection.end);
+  });
+  return nextValue;
+};
+var toggleHeadingLine = (textarea, level) => {
+  const { lineEnd, lineStart, text } = getSelectedLineRange(textarea);
+  const lines = text.split("\n");
+  const targetPrefix = `${"#".repeat(level)} `;
+  if (lines.length === 1 && lines[0].trim().length === 0) {
+    const nextValue = [
+      textarea.value.slice(0, lineStart),
+      targetPrefix,
+      textarea.value.slice(lineEnd)
+    ].join("");
+    setPendingSelection(textarea, lineStart + targetPrefix.length, lineStart + targetPrefix.length);
+    return nextValue;
+  }
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  const shouldRemoveTargetPrefix = nonEmptyLines.length > 0 && nonEmptyLines.every((line) => line.startsWith(targetPrefix));
+  const nextLines = lines.map((line) => {
+    if (line.trim().length === 0) return line;
+    if (shouldRemoveTargetPrefix) {
+      return line.startsWith(targetPrefix) ? line.slice(targetPrefix.length) : line;
+    }
+    return line.replace(headingPrefixPattern, "") === line ? `${targetPrefix}${line}` : line.replace(headingPrefixPattern, targetPrefix);
+  });
+  return replaceSelectedLineRange(textarea, nextLines.join("\n"), lineStart, lineEnd);
+};
+var continueMarkdownList = (textarea) => {
+  const { selectionEnd, selectionStart, value } = textarea;
+  if (selectionStart !== selectionEnd) return null;
+  const lineStart = value.lastIndexOf("\n", selectionStart - 1) + 1;
+  const lineEnd = value.indexOf("\n", selectionStart);
+  const resolvedLineEnd = lineEnd === -1 ? value.length : lineEnd;
+  const currentLine = value.slice(lineStart, resolvedLineEnd);
+  const unorderedMatch = currentLine.match(unorderedListPattern);
+  if (unorderedMatch) {
+    const [, indent, marker, content] = unorderedMatch;
+    const nextLine = content.trim().length === 0 ? "" : `
+${indent}${marker} `;
+    const nextValue = `${value.slice(0, selectionStart)}${nextLine}${value.slice(selectionEnd)}`;
+    const nextCursor = selectionStart + nextLine.length;
+    setPendingSelection(textarea, nextCursor, nextCursor);
+    return nextValue;
+  }
+  const unorderedMarkerOnlyMatch = currentLine.match(unorderedListMarkerOnlyPattern);
+  if (unorderedMarkerOnlyMatch) {
+    const [, indent] = unorderedMarkerOnlyMatch;
+    const replacement = indent;
+    const nextValue = [value.slice(0, lineStart), replacement, value.slice(resolvedLineEnd)].join(
+      ""
+    );
+    const nextCursor = lineStart + replacement.length;
+    setPendingSelection(textarea, nextCursor, nextCursor);
+    return nextValue;
+  }
+  const orderedMatch = currentLine.match(orderedListPattern);
+  if (orderedMatch) {
+    const [, indent, numberText, content] = orderedMatch;
+    const nextLine = content.trim().length === 0 ? "" : `
+${indent}${Number(numberText) + 1}. `;
+    const nextValue = `${value.slice(0, selectionStart)}${nextLine}${value.slice(selectionEnd)}`;
+    const nextCursor = selectionStart + nextLine.length;
+    setPendingSelection(textarea, nextCursor, nextCursor);
+    return nextValue;
+  }
+  const orderedMarkerOnlyMatch = currentLine.match(orderedListMarkerOnlyPattern);
+  if (orderedMarkerOnlyMatch) {
+    const [, indent] = orderedMarkerOnlyMatch;
+    const replacement = indent;
+    const nextValue = [value.slice(0, lineStart), replacement, value.slice(resolvedLineEnd)].join(
+      ""
+    );
+    const nextCursor = lineStart + replacement.length;
+    setPendingSelection(textarea, nextCursor, nextCursor);
+    return nextValue;
+  }
+  return null;
+};
+var indentMarkdownList = (textarea) => {
+  const { lineEnd, lineStart, text } = getSelectedLineRange(textarea);
+  const lines = text.split("\n");
+  if (!lines.some((line) => listItemPattern.test(line))) {
+    return null;
+  }
+  const nextLines = lines.map((line) => listItemPattern.test(line) ? `  ${line}` : line);
+  return replaceSelectedLineRange(textarea, nextLines.join("\n"), lineStart, lineEnd);
+};
+var outdentMarkdownList = (textarea) => {
+  const { lineEnd, lineStart, text } = getSelectedLineRange(textarea);
+  const lines = text.split("\n");
+  if (!lines.some((line) => listItemPattern.test(line))) {
+    return null;
+  }
+  const nextLines = lines.map((line) => {
+    if (!listItemPattern.test(line)) return line;
+    if (line.startsWith("  ")) return line.slice(2);
+    if (line.startsWith("	")) return line.slice(1);
+    return line;
+  });
+  return replaceSelectedLineRange(textarea, nextLines.join("\n"), lineStart, lineEnd);
+};
+
+// src/entities/editor-core/model/theme-contract.ts
+var CHAEDITOR_THEME_VARIABLES = {
+  border: "--chaeditor-color-border",
+  borderStrong: "--chaeditor-color-border-strong",
+  focusRing: "--chaeditor-color-focus-ring",
+  monoFont: "--chaeditor-font-mono",
+  muted: "--chaeditor-color-muted",
+  overlayBackdrop: "--chaeditor-color-overlay-backdrop",
+  primary: "--chaeditor-color-primary",
+  primaryContrast: "--chaeditor-color-primary-contrast",
+  primaryHover: "--chaeditor-color-primary-hover",
+  primaryMuted: "--chaeditor-color-primary-muted",
+  primarySubtle: "--chaeditor-color-primary-subtle",
+  sansFont: "--chaeditor-font-sans",
+  sansJaFont: "--chaeditor-font-sans-ja",
+  success: "--chaeditor-color-success",
+  surface: "--chaeditor-color-surface",
+  surfaceMuted: "--chaeditor-color-surface-muted",
+  surfaceStrong: "--chaeditor-color-surface-strong",
+  text: "--chaeditor-color-text",
+  textSubtle: "--chaeditor-color-text-subtle",
+  error: "--chaeditor-color-error"
+};
+var CHAEDITOR_THEME_DEFAULTS = {
+  dark: {
+    border: "#52525b",
+    borderStrong: "#71717a",
+    error: "#f87171",
+    focusRing: "#1e3a8a",
+    muted: "#a1a1aa",
+    overlayBackdrop: "rgb(9 9 11 / 0.82)",
+    primary: "#93c5fd",
+    primaryContrast: "#18181b",
+    primaryHover: "#bfdbfe",
+    primaryMuted: "#1e40af",
+    primarySubtle: "#1e3a8a",
+    success: "#4ade80",
+    surface: "#18181b",
+    surfaceMuted: "#27272a",
+    surfaceStrong: "#3f3f46",
+    text: "#fafafa",
+    textSubtle: "#d4d4d8"
+  },
+  fonts: {
+    mono: "var(--font-d2coding), 'D2Coding', 'SFMono-Regular', 'JetBrains Mono', Consolas, 'Liberation Mono', monospace",
+    sans: "system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif",
+    sansJa: "system-ui, -apple-system, BlinkMacSystemFont, 'Hiragino Sans', 'Yu Gothic', 'Meiryo', sans-serif"
+  },
+  light: {
+    border: "#d4d4d8",
+    borderStrong: "#a1a1aa",
+    error: "#ef4444",
+    focusRing: "#dbeafe",
+    muted: "#71717a",
+    overlayBackdrop: "rgb(15 23 42 / 0.86)",
+    primary: "#3b82f6",
+    primaryContrast: "#ffffff",
+    primaryHover: "#2563eb",
+    primaryMuted: "#dbeafe",
+    primarySubtle: "#eff6ff",
+    success: "#22c55e",
+    surface: "#ffffff",
+    surfaceMuted: "#f4f4f5",
+    surfaceStrong: "#e4e4e7",
+    text: "#18181b",
+    textSubtle: "#52525b"
+  }
+};
+var createChaeditorThemeVars = (theme) => {
+  const vars = {};
+  if (theme.border) vars[CHAEDITOR_THEME_VARIABLES.border] = theme.border;
+  if (theme.borderStrong) vars[CHAEDITOR_THEME_VARIABLES.borderStrong] = theme.borderStrong;
+  if (theme.error) vars[CHAEDITOR_THEME_VARIABLES.error] = theme.error;
+  if (theme.focusRing) vars[CHAEDITOR_THEME_VARIABLES.focusRing] = theme.focusRing;
+  if (theme.monoFont) vars[CHAEDITOR_THEME_VARIABLES.monoFont] = theme.monoFont;
+  if (theme.muted) vars[CHAEDITOR_THEME_VARIABLES.muted] = theme.muted;
+  if (theme.overlayBackdrop) {
+    vars[CHAEDITOR_THEME_VARIABLES.overlayBackdrop] = theme.overlayBackdrop;
+  }
+  if (theme.primary) vars[CHAEDITOR_THEME_VARIABLES.primary] = theme.primary;
+  if (theme.primaryContrast) {
+    vars[CHAEDITOR_THEME_VARIABLES.primaryContrast] = theme.primaryContrast;
+  }
+  if (theme.primaryHover) vars[CHAEDITOR_THEME_VARIABLES.primaryHover] = theme.primaryHover;
+  if (theme.primaryMuted) vars[CHAEDITOR_THEME_VARIABLES.primaryMuted] = theme.primaryMuted;
+  if (theme.primarySubtle) vars[CHAEDITOR_THEME_VARIABLES.primarySubtle] = theme.primarySubtle;
+  if (theme.sansFont) vars[CHAEDITOR_THEME_VARIABLES.sansFont] = theme.sansFont;
+  if (theme.sansJaFont) vars[CHAEDITOR_THEME_VARIABLES.sansJaFont] = theme.sansJaFont;
+  if (theme.success) vars[CHAEDITOR_THEME_VARIABLES.success] = theme.success;
+  if (theme.surface) vars[CHAEDITOR_THEME_VARIABLES.surface] = theme.surface;
+  if (theme.surfaceMuted) vars[CHAEDITOR_THEME_VARIABLES.surfaceMuted] = theme.surfaceMuted;
+  if (theme.surfaceStrong) vars[CHAEDITOR_THEME_VARIABLES.surfaceStrong] = theme.surfaceStrong;
+  if (theme.text) vars[CHAEDITOR_THEME_VARIABLES.text] = theme.text;
+  if (theme.textSubtle) vars[CHAEDITOR_THEME_VARIABLES.textSubtle] = theme.textSubtle;
+  return vars;
+};
+
+// src/entities/editor-core/model/toolbar-preset.ts
+var DEFAULT_MARKDOWN_TOOLBAR_PRESET = [
+  {
+    itemKeys: ["heading-popover", "subtext"],
+    key: "heading-and-subtext"
+  },
+  {
+    itemKeys: ["bold", "italic", "strike", "underline"],
+    key: "text-emphasis"
+  },
+  {
+    itemKeys: ["text-color", "background-color", "align"],
+    key: "highlight-and-alignment"
+  },
+  {
+    itemKeys: ["horizontal-rule", "quote", "code-block", "table", "spoiler", "toggle-popover"],
+    key: "block-syntax"
+  },
+  {
+    itemKeys: ["math-embed", "file-embed", "image-embed", "link-embed", "video-embed"],
+    key: "embed-and-media"
+  }
+];
+var resolveMarkdownToolbarPresetSections = ({
+  itemRegistry,
+  preset = DEFAULT_MARKDOWN_TOOLBAR_PRESET
+}) => preset.map((section) => ({
+  items: section.itemKeys.map((itemKey) => itemRegistry[itemKey]).filter((item) => item !== void 0),
+  key: section.key
+}));
+
+exports.CHAEDITOR_THEME_DEFAULTS = CHAEDITOR_THEME_DEFAULTS;
+exports.CHAEDITOR_THEME_VARIABLES = CHAEDITOR_THEME_VARIABLES;
+exports.DEFAULT_MARKDOWN_TOOLBAR_PRESET = DEFAULT_MARKDOWN_TOOLBAR_PRESET;
+exports.EDITOR_ATTACHMENT_FILE_INPUT_ACCEPT = EDITOR_ATTACHMENT_FILE_INPUT_ACCEPT;
+exports.EDITOR_ATTACHMENT_MAX_FILE_SIZE = EDITOR_ATTACHMENT_MAX_FILE_SIZE;
+exports.EDITOR_VIDEO_FILE_INPUT_ACCEPT = EDITOR_VIDEO_FILE_INPUT_ACCEPT;
+exports.EDITOR_VIDEO_MAX_FILE_SIZE = EDITOR_VIDEO_MAX_FILE_SIZE;
+exports.applyTextareaTransform = applyTextareaTransform;
+exports.buildEditorLinkInsertion = buildEditorLinkInsertion;
+exports.continueMarkdownList = continueMarkdownList;
+exports.createAlignBlockMarkdown = createAlignBlockMarkdown;
+exports.createAttachmentEmbedMarkdown = createAttachmentEmbedMarkdown;
+exports.createChaeditorThemeVars = createChaeditorThemeVars;
+exports.createImageEmbedMarkdown = createImageEmbedMarkdown;
+exports.createImageEmbedMarkdownGroup = createImageEmbedMarkdownGroup;
+exports.createImageGalleryMarkdown = createImageGalleryMarkdown;
+exports.createMarkdownLink = createMarkdownLink;
+exports.createMarkdownLinkByMode = createMarkdownLinkByMode;
+exports.createMathEmbedMarkdown = createMathEmbedMarkdown;
+exports.createToggleBlockMarkdown = createToggleBlockMarkdown;
+exports.createUploadedVideoEmbedMarkdown = createUploadedVideoEmbedMarkdown;
+exports.createVideoEmbedMarkdown = createVideoEmbedMarkdown;
+exports.createYoutubeEmbedMarkdown = createYoutubeEmbedMarkdown;
+exports.decodeHtmlAttributeEntities = decodeHtmlAttributeEntities;
+exports.extractVideoEmbedReference = extractVideoEmbedReference;
+exports.extractYoutubeId = extractYoutubeId;
+exports.focusTextarea = focusTextarea;
+exports.getPendingSelection = getPendingSelection;
+exports.indentMarkdownList = indentMarkdownList;
+exports.insertTemplate = insertTemplate;
+exports.isAllowedEditorAttachmentExtension = isAllowedEditorAttachmentExtension;
+exports.isAllowedEditorAttachmentFile = isAllowedEditorAttachmentFile;
+exports.isAllowedEditorVideoExtension = isAllowedEditorVideoExtension;
+exports.isAllowedEditorVideoFile = isAllowedEditorVideoFile;
+exports.normalizeMarkdownHtmlAliases = normalizeMarkdownHtmlAliases;
+exports.outdentMarkdownList = outdentMarkdownList;
+exports.parseRichMarkdownSegments = parseRichMarkdownSegments;
+exports.parseToggleTitle = parseToggleTitle;
+exports.prefixLine = prefixLine;
+exports.preprocessMarkdownInlineSyntax = preprocessMarkdownInlineSyntax;
+exports.resolveMarkdownToolbarPresetSections = resolveMarkdownToolbarPresetSections;
+exports.restoreCursor = restoreCursor;
+exports.toggleHeadingLine = toggleHeadingLine;
+exports.transformMarkdownOutsideCode = transformMarkdownOutsideCode;
+exports.wrapSelection = wrapSelection;