@bendyline/squisq-editor-react 2.8.0 → 2.10.0

package/dist/{chunk-YPRX32GY.js → chunk-JYPLPGYJ.js}

@@ -1,7 +1,7 @@
 import {
   markdownToTiptap,
   tiptapToMarkdown
-} from "./chunk-K2WJYVS4.js";
+} from "./chunk-TCLNRATG.js";
 
 // src/jsonEditor/JsonEditorContext.tsx
 import { createContext, useContext, useEffect, useMemo } from "react";

package/dist/chunk-SAKLIEOX.js

@@ -0,0 +1,144 @@
+// src/proofing/harperProvider.ts
+import {
+  categorizeLintKind
+} from "@bendyline/squisq/proof";
+var SUGGESTION_KINDS = ["replace", "remove", "insertAfter"];
+var MAX_IGNORE_ROUNDS = 5;
+function createHarperProofingProvider(config = {}) {
+  let enginePromise = null;
+  let lastPass = null;
+  let disposed = false;
+  const words = new Set(config.initialWords ?? []);
+  const load = async () => {
+    const harper = await import("harper.js");
+    let binary = config.binary;
+    if (binary === void 0) {
+      if (config.wasmUrl) {
+        const absolute = typeof location !== "undefined" ? new URL(config.wasmUrl, location.href).toString() : config.wasmUrl;
+        binary = harper.createBinaryModuleFromUrl(absolute);
+      } else {
+        binary = (await import("harper.js/binary")).binary;
+      }
+    }
+    const dialect = harper.Dialect[config.dialect ?? "American"];
+    const init = { binary, dialect };
+    const linter = typeof Worker !== "undefined" ? new harper.WorkerLinter(init) : new harper.LocalLinter(init);
+    await linter.setup();
+    if (words.size > 0) await linter.importWords([...words]);
+    return { harper, linter };
+  };
+  const ensure = () => {
+    if (disposed) return Promise.reject(new Error("ProofingProvider has been disposed"));
+    if (!enginePromise) {
+      enginePromise = load().catch((err) => {
+        enginePromise = null;
+        throw err;
+      });
+    }
+    return enginePromise;
+  };
+  const toFinding = (lint, id, text) => {
+    const span = lint.span();
+    const kind = lint.lint_kind();
+    return {
+      id,
+      start: span.start,
+      end: span.end,
+      category: categorizeLintKind(kind),
+      kind,
+      message: lint.message(),
+      originalText: text.slice(span.start, span.end),
+      suggestions: lint.suggestions().map((suggestion) => ({
+        text: suggestion.get_replacement_text(),
+        kind: SUGGESTION_KINDS[suggestion.kind()] ?? "replace"
+      }))
+    };
+  };
+  let passCounter = 0;
+  return {
+    // App-level additions only persist if the host gave us somewhere to
+    // put them; without a callback the editor hides that menu item.
+    hasAppDictionary: config.onDictionaryWord != null,
+    async setup() {
+      await ensure();
+    },
+    async lint(text, options) {
+      const { linter } = await ensure();
+      const language = options?.language ?? "plaintext";
+      const lints = await linter.lint(text, { language });
+      passCounter += 1;
+      const byId = /* @__PURE__ */ new Map();
+      const findings = lints.map((lint, index) => {
+        const id = `${passCounter}:${index}`;
+        const finding = toFinding(lint, id, text);
+        byId.set(id, { lint, start: finding.start, end: finding.end });
+        return finding;
+      });
+      lastPass = { source: text, language, byId };
+      return findings;
+    },
+    async ignoreFinding(findingId) {
+      const { linter } = await ensure();
+      const pass = lastPass;
+      const entry = pass?.byId.get(findingId);
+      if (!pass || !entry) {
+        console.warn("squisq proofing: ignoreFinding called with a stale finding id", findingId);
+        return;
+      }
+      let lint = entry.lint;
+      for (let round = 0; round < MAX_IGNORE_ROUNDS && lint; round += 1) {
+        await linter.ignoreLint(pass.source, lint);
+        const relint = await linter.lint(pass.source, { language: pass.language });
+        lint = relint.find(
+          (candidate) => candidate.span().start === entry.start && candidate.span().end === entry.end
+        );
+      }
+    },
+    async addWord(word) {
+      const { linter } = await ensure();
+      words.add(word);
+      await linter.importWords([...words]);
+      config.onDictionaryWord?.(word);
+    },
+    async addWords(list) {
+      if (list.length === 0) return;
+      const { linter } = await ensure();
+      for (const word of list) words.add(word);
+      await linter.importWords([...words]);
+    },
+    async exportIgnored() {
+      const { linter } = await ensure();
+      return linter.exportIgnoredLints();
+    },
+    async clearIgnored() {
+      const { linter } = await ensure();
+      await linter.clearIgnoredLints();
+    },
+    async importIgnored(json) {
+      const { linter } = await ensure();
+      await linter.importIgnoredLints(json);
+    },
+    async setDialect(dialect) {
+      const { harper, linter } = await ensure();
+      await linter.setDialect(harper.Dialect[dialect]);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      lastPass = null;
+      const pending = enginePromise;
+      enginePromise = null;
+      void pending?.then((handle) => handle.linter.dispose()).catch(() => {
+      });
+    }
+  };
+}
+
+// src/proofing/index.ts
+import { PROOF_DIALECTS, PROOF_FRONTMATTER_KEYS } from "@bendyline/squisq/proof";
+
+export {
+  createHarperProofingProvider,
+  PROOF_DIALECTS,
+  PROOF_FRONTMATTER_KEYS
+};

package/dist/{chunk-K2WJYVS4.js → chunk-TCLNRATG.js}

@@ -10,6 +10,8 @@ var RE_BOLD_UNDER = /(?<![\p{L}\p{N}_])__(?![\s_])(.+?)(?<![\s_])__(?![\p{L}\p{N
 var RE_ITALIC_STAR = /\*(?![\s*])(.+?)(?<![\s*])\*/g;
 var RE_ITALIC_UNDER = /(?<![\p{L}\p{N}_])_(?![\s_])(.+?)(?<![\s_])_(?![\p{L}\p{N}_])/gu;
 var RE_STRIKETHROUGH = /~~(.+?)~~/g;
+var RE_LEGACY_BOLD_STAR = /\*\*(?![\s*])(.+?)(?<![\s*])([ \t]+)\*\*(?=$|[^\s*])/g;
+var RE_LEGACY_ITALIC_STAR = /(?<!\*)\*(?![\s*])(.+?)(?<![\s*])([ \t]+)\*(?=$|[^\s*])/g;
 var ESCAPABLE_MD_CHARS = ["*", "_", "~", "\\"];
 var RE_MD_ESCAPE = /\\([*_~\\])/g;
 var RE_INLINE_CODE = /`(.+?)`/g;
@@ -18,13 +20,9 @@ var RE_MENTION = /@\[([^\]]+?)\]\(([a-z][a-z0-9+.-]*)\\?:([^)\s]+)\)/gi;
 var RE_MENTION_TAG = /<span\b[^>]*?\bdata-mention\b[^>]*?>(?:<[^>]+>)*([^<]*)<\/span>/gi;
 var RE_ICON_MD = /\{\[([a-zA-Z0-9_:-]+)\]\}/g;
 var RE_ICON_TAG = /<i\b[^>]*?\bdata-icon="([^"]*)"[^>]*?><\/i>/gi;
-var RE_STRONG_TAG = /<strong>(.*?)<\/strong>/g;
-var RE_B_TAG = /<b>(.*?)<\/b>/g;
-var RE_EM_TAG = /<em>(.*?)<\/em>/g;
-var RE_I_TAG = /<i>(.*?)<\/i>/g;
-var RE_S_TAG = /<s>(.*?)<\/s>/g;
-var RE_DEL_TAG = /<del>(.*?)<\/del>/g;
+var RE_MARK_TAG = /<(strong|b|em|i|s|del|sup|sub)>(.*?)<\/\1>/gs;
 var RE_CODE_TAG = /<code>(.*?)<\/code>/g;
+var RE_VERT_ALIGN_TAG = /<(sup|sub)>((?:(?!<\/?(?:sup|sub)>)[\s\S])*)<\/\1>/gi;
 var RE_A_TAG = /<a\b([^>]*)>(.*?)<\/a>/g;
 var RE_IMG_TAG = /<img\b([^>]*)>/g;
 var RE_STRIP_TAGS = /<[^>]+>/g;
@@ -787,6 +785,10 @@ function inlineToHtml(text) {
     RE_INLINE_CODE,
     (_m, code) => stash(`<code>${escapeHtml(code)}</code>`)
   );
+  staged = staged.replace(RE_VERT_ALIGN_TAG, (_m, tag, inner) => {
+    const name = tag.toLowerCase();
+    return stash(`<${name}>${inlineToHtml(inner)}</${name}>`);
+  });
   staged = staged.replace(
     RE_IMAGE,
     (_m, alt, src) => stash(`<img alt="${escapeHtml(alt)}" src="${escapeHtml(src)}">`)
@@ -814,8 +816,10 @@ function inlineToHtml(text) {
     RE_MD_ESCAPE,
     (_m, ch) => `\0ESC${ESCAPABLE_MD_CHARS.indexOf(ch)}\0`
   );
+  result = result.replace(RE_LEGACY_BOLD_STAR, "<strong>$1</strong>$2");
   result = result.replace(RE_BOLD_STAR, "<strong>$1</strong>");
   result = result.replace(RE_BOLD_UNDER, "<strong>$1</strong>");
+  result = result.replace(RE_LEGACY_ITALIC_STAR, "<em>$1</em>$2");
   result = result.replace(RE_ITALIC_STAR, "<em>$1</em>");
   result = result.replace(RE_ITALIC_UNDER, "<em>$1</em>");
   result = result.replace(RE_STRIKETHROUGH, "<s>$1</s>");
@@ -961,17 +965,46 @@ function escapeMarkdownTextNodes(html) {
   }
   return out + escapeMarkdownText(html.slice(cursor));
 }
+function markdownFromMarkTags(html) {
+  return html.replace(RE_MARK_TAG, (_match, tag, inner) => {
+    const convertedInner = markdownFromMarkTags(inner);
+    const leading = convertedInner.match(/^\s*/)?.[0] ?? "";
+    const trailing = convertedInner.match(/\s*$/)?.[0] ?? "";
+    const content = convertedInner.slice(leading.length, convertedInner.length - trailing.length);
+    if (!content) return convertedInner;
+    if (tag === "sup" || tag === "sub") {
+      return `${leading}<${tag}>${content}</${tag}>${trailing}`;
+    }
+    const delimiter = tag === "strong" || tag === "b" ? "**" : tag === "em" || tag === "i" ? "*" : "~~";
+    return `${leading}${delimiter}${content}${delimiter}${trailing}`;
+  });
+}
+var RawHtmlVault = class {
+  constructor() {
+    this.parts = [];
+  }
+  /** Replace a raw HTML string with a sentinel the tag-stripper won't match. */
+  protect(html) {
+    this.parts.push(html);
+    return `\0RAW${this.parts.length - 1}\0`;
+  }
+  /** Swap every sentinel back for its raw HTML. */
+  restore(text) {
+    let out = text;
+    for (let i = this.parts.length - 1; i >= 0; i--) {
+      out = out.split(`\0RAW${i}\0`).join(this.parts[i]);
+    }
+    return out;
+  }
+};
 function htmlToInline(html) {
   let result = html;
+  const vault = new RawHtmlVault();
   result = result.replace(/<br\s*\/?>/gi, "  \n");
   result = escapeMarkdownTextNodes(result);
   result = result.replace(RE_ICON_TAG, (_m, token) => `{[${token}]}`);
-  result = result.replace(RE_STRONG_TAG, "**$1**");
-  result = result.replace(RE_B_TAG, "**$1**");
-  result = result.replace(RE_EM_TAG, "*$1*");
-  result = result.replace(RE_I_TAG, "*$1*");
-  result = result.replace(RE_S_TAG, "~~$1~~");
-  result = result.replace(RE_DEL_TAG, "~~$1~~");
+  result = markdownFromMarkTags(result);
+  result = result.replace(/<\/?(?:sup|sub)>/gi, (tag) => vault.protect(tag));
   result = result.replace(RE_CODE_TAG, "`$1`");
   result = result.replace(RE_MENTION_TAG, (match, _inner) => {
     const kind = /data-kind="([^"]*)"/i.exec(match)?.[1] ?? "";
@@ -991,9 +1024,11 @@ function htmlToInline(html) {
     const src = /\bsrc="([^"]*)"/i.exec(attrs)?.[1];
     if (!src) return match;
     const alt = /\balt="([^"]*)"/i.exec(attrs)?.[1] ?? "";
-    return serializeImage(src, alt, attrs);
+    const serialized = serializeImage(src, alt, attrs);
+    return serialized.startsWith("<") ? vault.protect(serialized) : serialized;
   });
   result = result.replace(RE_STRIP_TAGS, "");
+  result = vault.restore(result);
   return restoreLeadingSpaces(unescapeHtml(result));
 }
 function preserveLeadingSpaces(html) {