@threadlabs/looma 0.1.5 → 0.1.6

package/editor/{chunk-YGJLGDQC.js → chunk-NJ2KAMS2.js}

@@ -1,3 +1,10 @@
+import {
+  TABLE_CELL_BACKGROUND_PRESETS
+} from "./chunk-CX4QDKSV.js";
+
+// src/extensions/preset.ts
+import { Extension as Extension7 } from "@tiptap/core";
+
 // ../../node_modules/.pnpm/@tiptap+extension-document@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-document/dist/index.js
 import { Node } from "@tiptap/core";
 var Document = Node.create({
@@ -3172,6 +3179,1663 @@ var CodeBlock = Node14.create({
   }
 });
 
+// ../../node_modules/.pnpm/@tiptap+extension-code-block-lowlight@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@ti_1435c0758b0eec843326ea7f0537cc85/node_modules/@tiptap/extension-code-block-lowlight/dist/index.js
+import { findChildren } from "@tiptap/core";
+import { Plugin as Plugin4, PluginKey as PluginKey4 } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function deepFreeze(obj) {
+  if (obj instanceof Map) {
+    obj.clear = obj.delete = obj.set = function() {
+      throw new Error("map is read-only");
+    };
+  } else if (obj instanceof Set) {
+    obj.add = obj.clear = obj.delete = function() {
+      throw new Error("set is read-only");
+    };
+  }
+  Object.freeze(obj);
+  Object.getOwnPropertyNames(obj).forEach((name) => {
+    const prop = obj[name];
+    const type = typeof prop;
+    if ((type === "object" || type === "function") && !Object.isFrozen(prop)) {
+      deepFreeze(prop);
+    }
+  });
+  return obj;
+}
+var Response = class {
+  /**
+   * @param {CompiledMode} mode
+   */
+  constructor(mode) {
+    if (mode.data === void 0) mode.data = {};
+    this.data = mode.data;
+    this.isMatchIgnored = false;
+  }
+  ignoreMatch() {
+    this.isMatchIgnored = true;
+  }
+};
+function escapeHTML(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+}
+function inherit$1(original, ...objects) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const key in original) {
+    result[key] = original[key];
+  }
+  objects.forEach(function(obj) {
+    for (const key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return (
+    /** @type {T} */
+    result
+  );
+}
+var SPAN_CLOSE = "</span>";
+var emitsWrappingTags = (node) => {
+  return !!node.scope;
+};
+var scopeToCSSClass = (name, { prefix }) => {
+  if (name.startsWith("language:")) {
+    return name.replace("language:", "language-");
+  }
+  if (name.includes(".")) {
+    const pieces = name.split(".");
+    return [
+      `${prefix}${pieces.shift()}`,
+      ...pieces.map((x, i) => `${x}${"_".repeat(i + 1)}`)
+    ].join(" ");
+  }
+  return `${prefix}${name}`;
+};
+var HTMLRenderer = class {
+  /**
+   * Creates a new HTMLRenderer
+   *
+   * @param {Tree} parseTree - the parse tree (must support `walk` API)
+   * @param {{classPrefix: string}} options
+   */
+  constructor(parseTree, options) {
+    this.buffer = "";
+    this.classPrefix = options.classPrefix;
+    parseTree.walk(this);
+  }
+  /**
+   * Adds texts to the output stream
+   *
+   * @param {string} text */
+  addText(text) {
+    this.buffer += escapeHTML(text);
+  }
+  /**
+   * Adds a node open to the output stream (if needed)
+   *
+   * @param {Node} node */
+  openNode(node) {
+    if (!emitsWrappingTags(node)) return;
+    const className = scopeToCSSClass(
+      node.scope,
+      { prefix: this.classPrefix }
+    );
+    this.span(className);
+  }
+  /**
+   * Adds a node close to the output stream (if needed)
+   *
+   * @param {Node} node */
+  closeNode(node) {
+    if (!emitsWrappingTags(node)) return;
+    this.buffer += SPAN_CLOSE;
+  }
+  /**
+   * returns the accumulated buffer
+  */
+  value() {
+    return this.buffer;
+  }
+  // helpers
+  /**
+   * Builds a span element
+   *
+   * @param {string} className */
+  span(className) {
+    this.buffer += `<span class="${className}">`;
+  }
+};
+var newNode = (opts = {}) => {
+  const result = { children: [] };
+  Object.assign(result, opts);
+  return result;
+};
+var TokenTree = class _TokenTree {
+  constructor() {
+    this.rootNode = newNode();
+    this.stack = [this.rootNode];
+  }
+  get top() {
+    return this.stack[this.stack.length - 1];
+  }
+  get root() {
+    return this.rootNode;
+  }
+  /** @param {Node} node */
+  add(node) {
+    this.top.children.push(node);
+  }
+  /** @param {string} scope */
+  openNode(scope) {
+    const node = newNode({ scope });
+    this.add(node);
+    this.stack.push(node);
+  }
+  closeNode() {
+    if (this.stack.length > 1) {
+      return this.stack.pop();
+    }
+    return void 0;
+  }
+  closeAllNodes() {
+    while (this.closeNode()) ;
+  }
+  toJSON() {
+    return JSON.stringify(this.rootNode, null, 4);
+  }
+  /**
+   * @typedef { import("./html_renderer").Renderer } Renderer
+   * @param {Renderer} builder
+   */
+  walk(builder) {
+    return this.constructor._walk(builder, this.rootNode);
+  }
+  /**
+   * @param {Renderer} builder
+   * @param {Node} node
+   */
+  static _walk(builder, node) {
+    if (typeof node === "string") {
+      builder.addText(node);
+    } else if (node.children) {
+      builder.openNode(node);
+      node.children.forEach((child) => this._walk(builder, child));
+      builder.closeNode(node);
+    }
+    return builder;
+  }
+  /**
+   * @param {Node} node
+   */
+  static _collapse(node) {
+    if (typeof node === "string") return;
+    if (!node.children) return;
+    if (node.children.every((el) => typeof el === "string")) {
+      node.children = [node.children.join("")];
+    } else {
+      node.children.forEach((child) => {
+        _TokenTree._collapse(child);
+      });
+    }
+  }
+};
+var TokenTreeEmitter = class extends TokenTree {
+  /**
+   * @param {*} options
+   */
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * @param {string} text
+   */
+  addText(text) {
+    if (text === "") {
+      return;
+    }
+    this.add(text);
+  }
+  /** @param {string} scope */
+  startScope(scope) {
+    this.openNode(scope);
+  }
+  endScope() {
+    this.closeNode();
+  }
+  /**
+   * @param {Emitter & {root: DataNode}} emitter
+   * @param {string} name
+   */
+  __addSublanguage(emitter, name) {
+    const node = emitter.root;
+    if (name) node.scope = `language:${name}`;
+    this.add(node);
+  }
+  toHTML() {
+    const renderer = new HTMLRenderer(this, this.options);
+    return renderer.value();
+  }
+  finalize() {
+    this.closeAllNodes();
+    return true;
+  }
+};
+function source(re) {
+  if (!re) return null;
+  if (typeof re === "string") return re;
+  return re.source;
+}
+function lookahead(re) {
+  return concat("(?=", re, ")");
+}
+function anyNumberOfTimes(re) {
+  return concat("(?:", re, ")*");
+}
+function optional(re) {
+  return concat("(?:", re, ")?");
+}
+function concat(...args) {
+  const joined = args.map((x) => source(x)).join("");
+  return joined;
+}
+function stripOptionsFromArgs(args) {
+  const opts = args[args.length - 1];
+  if (typeof opts === "object" && opts.constructor === Object) {
+    args.splice(args.length - 1, 1);
+    return opts;
+  } else {
+    return {};
+  }
+}
+function either(...args) {
+  const opts = stripOptionsFromArgs(args);
+  const joined = "(" + (opts.capture ? "" : "?:") + args.map((x) => source(x)).join("|") + ")";
+  return joined;
+}
+function countMatchGroups(re) {
+  return new RegExp(re.toString() + "|").exec("").length - 1;
+}
+function startsWith(re, lexeme) {
+  const match = re && re.exec(lexeme);
+  return match && match.index === 0;
+}
+var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
+function _rewriteBackreferences(regexps, { joinWith }) {
+  let numCaptures = 0;
+  return regexps.map((regex) => {
+    numCaptures += 1;
+    const offset = numCaptures;
+    let re = source(regex);
+    let out = "";
+    while (re.length > 0) {
+      const match = BACKREF_RE.exec(re);
+      if (!match) {
+        out += re;
+        break;
+      }
+      out += re.substring(0, match.index);
+      re = re.substring(match.index + match[0].length);
+      if (match[0][0] === "\\" && match[1]) {
+        out += "\\" + String(Number(match[1]) + offset);
+      } else {
+        out += match[0];
+        if (match[0] === "(") {
+          numCaptures++;
+        }
+      }
+    }
+    return out;
+  }).map((re) => `(${re})`).join(joinWith);
+}
+var MATCH_NOTHING_RE = /\b\B/;
+var IDENT_RE = "[a-zA-Z]\\w*";
+var UNDERSCORE_IDENT_RE = "[a-zA-Z_]\\w*";
+var NUMBER_RE = "\\b\\d+(\\.\\d+)?";
+var C_NUMBER_RE = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)";
+var BINARY_NUMBER_RE = "\\b(0b[01]+)";
+var RE_STARTERS_RE = "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~";
+var SHEBANG = (opts = {}) => {
+  const beginShebang = /^#![ ]*\//;
+  if (opts.binary) {
+    opts.begin = concat(
+      beginShebang,
+      /.*\b/,
+      opts.binary,
+      /\b.*/
+    );
+  }
+  return inherit$1({
+    scope: "meta",
+    begin: beginShebang,
+    end: /$/,
+    relevance: 0,
+    /** @type {ModeCallback} */
+    "on:begin": (m, resp) => {
+      if (m.index !== 0) resp.ignoreMatch();
+    }
+  }, opts);
+};
+var BACKSLASH_ESCAPE = {
+  begin: "\\\\[\\s\\S]",
+  relevance: 0
+};
+var APOS_STRING_MODE = {
+  scope: "string",
+  begin: "'",
+  end: "'",
+  illegal: "\\n",
+  contains: [BACKSLASH_ESCAPE]
+};
+var QUOTE_STRING_MODE = {
+  scope: "string",
+  begin: '"',
+  end: '"',
+  illegal: "\\n",
+  contains: [BACKSLASH_ESCAPE]
+};
+var PHRASAL_WORDS_MODE = {
+  begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+};
+var COMMENT = function(begin, end, modeOptions = {}) {
+  const mode = inherit$1(
+    {
+      scope: "comment",
+      begin,
+      end,
+      contains: []
+    },
+    modeOptions
+  );
+  mode.contains.push({
+    scope: "doctag",
+    // hack to avoid the space from being included. the space is necessary to
+    // match here to prevent the plain text rule below from gobbling up doctags
+    begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+    end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,
+    excludeBegin: true,
+    relevance: 0
+  });
+  const ENGLISH_WORD = either(
+    // list of common 1 and 2 letter words in English
+    "I",
+    "a",
+    "is",
+    "so",
+    "us",
+    "to",
+    "at",
+    "if",
+    "in",
+    "it",
+    "on",
+    // note: this is not an exhaustive list of contractions, just popular ones
+    /[A-Za-z]+['](d|ve|re|ll|t|s|n)/,
+    // contractions - can't we'd they're let's, etc
+    /[A-Za-z]+[-][a-z]+/,
+    // `no-way`, etc.
+    /[A-Za-z][a-z]{2,}/
+    // allow capitalized words at beginning of sentences
+  );
+  mode.contains.push(
+    {
+      // TODO: how to include ", (, ) without breaking grammars that use these for
+      // comment delimiters?
+      // begin: /[ ]+([()"]?([A-Za-z'-]{3,}|is|a|I|so|us|[tT][oO]|at|if|in|it|on)[.]?[()":]?([.][ ]|[ ]|\))){3}/
+      // ---
+      // this tries to find sequences of 3 english words in a row (without any
+      // "programming" type syntax) this gives us a strong signal that we've
+      // TRULY found a comment - vs perhaps scanning with the wrong language.
+      // It's possible to find something that LOOKS like the start of the
+      // comment - but then if there is no readable text - good chance it is a
+      // false match and not a comment.
+      //
+      // for a visual example please see:
+      // https://github.com/highlightjs/highlight.js/issues/2827
+      begin: concat(
+        /[ ]+/,
+        // necessary to prevent us gobbling up doctags like /* @author Bob Mcgill */
+        "(",
+        ENGLISH_WORD,
+        /[.]?[:]?([.][ ]|[ ])/,
+        "){3}"
+      )
+      // look for 3 words in a row
+    }
+  );
+  return mode;
+};
+var C_LINE_COMMENT_MODE = COMMENT("//", "$");
+var C_BLOCK_COMMENT_MODE = COMMENT("/\\*", "\\*/");
+var HASH_COMMENT_MODE = COMMENT("#", "$");
+var NUMBER_MODE = {
+  scope: "number",
+  begin: NUMBER_RE,
+  relevance: 0
+};
+var C_NUMBER_MODE = {
+  scope: "number",
+  begin: C_NUMBER_RE,
+  relevance: 0
+};
+var BINARY_NUMBER_MODE = {
+  scope: "number",
+  begin: BINARY_NUMBER_RE,
+  relevance: 0
+};
+var REGEXP_MODE = {
+  scope: "regexp",
+  begin: /\/(?=[^/\n]*\/)/,
+  end: /\/[gimuy]*/,
+  contains: [
+    BACKSLASH_ESCAPE,
+    {
+      begin: /\[/,
+      end: /\]/,
+      relevance: 0,
+      contains: [BACKSLASH_ESCAPE]
+    }
+  ]
+};
+var TITLE_MODE = {
+  scope: "title",
+  begin: IDENT_RE,
+  relevance: 0
+};
+var UNDERSCORE_TITLE_MODE = {
+  scope: "title",
+  begin: UNDERSCORE_IDENT_RE,
+  relevance: 0
+};
+var METHOD_GUARD = {
+  // excludes method names from keyword processing
+  begin: "\\.\\s*" + UNDERSCORE_IDENT_RE,
+  relevance: 0
+};
+var END_SAME_AS_BEGIN = function(mode) {
+  return Object.assign(
+    mode,
+    {
+      /** @type {ModeCallback} */
+      "on:begin": (m, resp) => {
+        resp.data._beginMatch = m[1];
+      },
+      /** @type {ModeCallback} */
+      "on:end": (m, resp) => {
+        if (resp.data._beginMatch !== m[1]) resp.ignoreMatch();
+      }
+    }
+  );
+};
+var MODES = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  APOS_STRING_MODE,
+  BACKSLASH_ESCAPE,
+  BINARY_NUMBER_MODE,
+  BINARY_NUMBER_RE,
+  COMMENT,
+  C_BLOCK_COMMENT_MODE,
+  C_LINE_COMMENT_MODE,
+  C_NUMBER_MODE,
+  C_NUMBER_RE,
+  END_SAME_AS_BEGIN,
+  HASH_COMMENT_MODE,
+  IDENT_RE,
+  MATCH_NOTHING_RE,
+  METHOD_GUARD,
+  NUMBER_MODE,
+  NUMBER_RE,
+  PHRASAL_WORDS_MODE,
+  QUOTE_STRING_MODE,
+  REGEXP_MODE,
+  RE_STARTERS_RE,
+  SHEBANG,
+  TITLE_MODE,
+  UNDERSCORE_IDENT_RE,
+  UNDERSCORE_TITLE_MODE
+});
+function skipIfHasPrecedingDot(match, response) {
+  const before = match.input[match.index - 1];
+  if (before === ".") {
+    response.ignoreMatch();
+  }
+}
+function scopeClassName(mode, _parent) {
+  if (mode.className !== void 0) {
+    mode.scope = mode.className;
+    delete mode.className;
+  }
+}
+function beginKeywords(mode, parent) {
+  if (!parent) return;
+  if (!mode.beginKeywords) return;
+  mode.begin = "\\b(" + mode.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)";
+  mode.__beforeBegin = skipIfHasPrecedingDot;
+  mode.keywords = mode.keywords || mode.beginKeywords;
+  delete mode.beginKeywords;
+  if (mode.relevance === void 0) mode.relevance = 0;
+}
+function compileIllegal(mode, _parent) {
+  if (!Array.isArray(mode.illegal)) return;
+  mode.illegal = either(...mode.illegal);
+}
+function compileMatch(mode, _parent) {
+  if (!mode.match) return;
+  if (mode.begin || mode.end) throw new Error("begin & end are not supported with match");
+  mode.begin = mode.match;
+  delete mode.match;
+}
+function compileRelevance(mode, _parent) {
+  if (mode.relevance === void 0) mode.relevance = 1;
+}
+var beforeMatchExt = (mode, parent) => {
+  if (!mode.beforeMatch) return;
+  if (mode.starts) throw new Error("beforeMatch cannot be used with starts");
+  const originalMode = Object.assign({}, mode);
+  Object.keys(mode).forEach((key) => {
+    delete mode[key];
+  });
+  mode.keywords = originalMode.keywords;
+  mode.begin = concat(originalMode.beforeMatch, lookahead(originalMode.begin));
+  mode.starts = {
+    relevance: 0,
+    contains: [
+      Object.assign(originalMode, { endsParent: true })
+    ]
+  };
+  mode.relevance = 0;
+  delete originalMode.beforeMatch;
+};
+var COMMON_KEYWORDS = [
+  "of",
+  "and",
+  "for",
+  "in",
+  "not",
+  "or",
+  "if",
+  "then",
+  "parent",
+  // common variable name
+  "list",
+  // common variable name
+  "value"
+  // common variable name
+];
+var DEFAULT_KEYWORD_SCOPE = "keyword";
+function compileKeywords(rawKeywords, caseInsensitive, scopeName = DEFAULT_KEYWORD_SCOPE) {
+  const compiledKeywords = /* @__PURE__ */ Object.create(null);
+  if (typeof rawKeywords === "string") {
+    compileList(scopeName, rawKeywords.split(" "));
+  } else if (Array.isArray(rawKeywords)) {
+    compileList(scopeName, rawKeywords);
+  } else {
+    Object.keys(rawKeywords).forEach(function(scopeName2) {
+      Object.assign(
+        compiledKeywords,
+        compileKeywords(rawKeywords[scopeName2], caseInsensitive, scopeName2)
+      );
+    });
+  }
+  return compiledKeywords;
+  function compileList(scopeName2, keywordList) {
+    if (caseInsensitive) {
+      keywordList = keywordList.map((x) => x.toLowerCase());
+    }
+    keywordList.forEach(function(keyword) {
+      const pair = keyword.split("|");
+      compiledKeywords[pair[0]] = [scopeName2, scoreForKeyword(pair[0], pair[1])];
+    });
+  }
+}
+function scoreForKeyword(keyword, providedScore) {
+  if (providedScore) {
+    return Number(providedScore);
+  }
+  return commonKeyword(keyword) ? 0 : 1;
+}
+function commonKeyword(keyword) {
+  return COMMON_KEYWORDS.includes(keyword.toLowerCase());
+}
+var seenDeprecations = {};
+var error = (message) => {
+  console.error(message);
+};
+var warn2 = (message, ...args) => {
+  console.log(`WARN: ${message}`, ...args);
+};
+var deprecated = (version2, message) => {
+  if (seenDeprecations[`${version2}/${message}`]) return;
+  console.log(`Deprecated as of ${version2}. ${message}`);
+  seenDeprecations[`${version2}/${message}`] = true;
+};
+var MultiClassError = new Error();
+function remapScopeNames(mode, regexes, { key }) {
+  let offset = 0;
+  const scopeNames = mode[key];
+  const emit = {};
+  const positions = {};
+  for (let i = 1; i <= regexes.length; i++) {
+    positions[i + offset] = scopeNames[i];
+    emit[i + offset] = true;
+    offset += countMatchGroups(regexes[i - 1]);
+  }
+  mode[key] = positions;
+  mode[key]._emit = emit;
+  mode[key]._multi = true;
+}
+function beginMultiClass(mode) {
+  if (!Array.isArray(mode.begin)) return;
+  if (mode.skip || mode.excludeBegin || mode.returnBegin) {
+    error("skip, excludeBegin, returnBegin not compatible with beginScope: {}");
+    throw MultiClassError;
+  }
+  if (typeof mode.beginScope !== "object" || mode.beginScope === null) {
+    error("beginScope must be object");
+    throw MultiClassError;
+  }
+  remapScopeNames(mode, mode.begin, { key: "beginScope" });
+  mode.begin = _rewriteBackreferences(mode.begin, { joinWith: "" });
+}
+function endMultiClass(mode) {
+  if (!Array.isArray(mode.end)) return;
+  if (mode.skip || mode.excludeEnd || mode.returnEnd) {
+    error("skip, excludeEnd, returnEnd not compatible with endScope: {}");
+    throw MultiClassError;
+  }
+  if (typeof mode.endScope !== "object" || mode.endScope === null) {
+    error("endScope must be object");
+    throw MultiClassError;
+  }
+  remapScopeNames(mode, mode.end, { key: "endScope" });
+  mode.end = _rewriteBackreferences(mode.end, { joinWith: "" });
+}
+function scopeSugar(mode) {
+  if (mode.scope && typeof mode.scope === "object" && mode.scope !== null) {
+    mode.beginScope = mode.scope;
+    delete mode.scope;
+  }
+}
+function MultiClass(mode) {
+  scopeSugar(mode);
+  if (typeof mode.beginScope === "string") {
+    mode.beginScope = { _wrap: mode.beginScope };
+  }
+  if (typeof mode.endScope === "string") {
+    mode.endScope = { _wrap: mode.endScope };
+  }
+  beginMultiClass(mode);
+  endMultiClass(mode);
+}
+function compileLanguage(language) {
+  function langRe(value, global) {
+    return new RegExp(
+      source(value),
+      "m" + (language.case_insensitive ? "i" : "") + (language.unicodeRegex ? "u" : "") + (global ? "g" : "")
+    );
+  }
+  class MultiRegex {
+    constructor() {
+      this.matchIndexes = {};
+      this.regexes = [];
+      this.matchAt = 1;
+      this.position = 0;
+    }
+    // @ts-ignore
+    addRule(re, opts) {
+      opts.position = this.position++;
+      this.matchIndexes[this.matchAt] = opts;
+      this.regexes.push([opts, re]);
+      this.matchAt += countMatchGroups(re) + 1;
+    }
+    compile() {
+      if (this.regexes.length === 0) {
+        this.exec = () => null;
+      }
+      const terminators = this.regexes.map((el) => el[1]);
+      this.matcherRe = langRe(_rewriteBackreferences(terminators, { joinWith: "|" }), true);
+      this.lastIndex = 0;
+    }
+    /** @param {string} s */
+    exec(s) {
+      this.matcherRe.lastIndex = this.lastIndex;
+      const match = this.matcherRe.exec(s);
+      if (!match) {
+        return null;
+      }
+      const i = match.findIndex((el, i2) => i2 > 0 && el !== void 0);
+      const matchData = this.matchIndexes[i];
+      match.splice(0, i);
+      return Object.assign(match, matchData);
+    }
+  }
+  class ResumableMultiRegex {
+    constructor() {
+      this.rules = [];
+      this.multiRegexes = [];
+      this.count = 0;
+      this.lastIndex = 0;
+      this.regexIndex = 0;
+    }
+    // @ts-ignore
+    getMatcher(index) {
+      if (this.multiRegexes[index]) return this.multiRegexes[index];
+      const matcher = new MultiRegex();
+      this.rules.slice(index).forEach(([re, opts]) => matcher.addRule(re, opts));
+      matcher.compile();
+      this.multiRegexes[index] = matcher;
+      return matcher;
+    }
+    resumingScanAtSamePosition() {
+      return this.regexIndex !== 0;
+    }
+    considerAll() {
+      this.regexIndex = 0;
+    }
+    // @ts-ignore
+    addRule(re, opts) {
+      this.rules.push([re, opts]);
+      if (opts.type === "begin") this.count++;
+    }
+    /** @param {string} s */
+    exec(s) {
+      const m = this.getMatcher(this.regexIndex);
+      m.lastIndex = this.lastIndex;
+      let result = m.exec(s);
+      if (this.resumingScanAtSamePosition()) {
+        if (result && result.index === this.lastIndex) ;
+        else {
+          const m2 = this.getMatcher(0);
+          m2.lastIndex = this.lastIndex + 1;
+          result = m2.exec(s);
+        }
+      }
+      if (result) {
+        this.regexIndex += result.position + 1;
+        if (this.regexIndex === this.count) {
+          this.considerAll();
+        }
+      }
+      return result;
+    }
+  }
+  function buildModeRegex(mode) {
+    const mm = new ResumableMultiRegex();
+    mode.contains.forEach((term) => mm.addRule(term.begin, { rule: term, type: "begin" }));
+    if (mode.terminatorEnd) {
+      mm.addRule(mode.terminatorEnd, { type: "end" });
+    }
+    if (mode.illegal) {
+      mm.addRule(mode.illegal, { type: "illegal" });
+    }
+    return mm;
+  }
+  function compileMode(mode, parent) {
+    const cmode = (
+      /** @type CompiledMode */
+      mode
+    );
+    if (mode.isCompiled) return cmode;
+    [
+      scopeClassName,
+      // do this early so compiler extensions generally don't have to worry about
+      // the distinction between match/begin
+      compileMatch,
+      MultiClass,
+      beforeMatchExt
+    ].forEach((ext) => ext(mode, parent));
+    language.compilerExtensions.forEach((ext) => ext(mode, parent));
+    mode.__beforeBegin = null;
+    [
+      beginKeywords,
+      // do this later so compiler extensions that come earlier have access to the
+      // raw array if they wanted to perhaps manipulate it, etc.
+      compileIllegal,
+      // default to 1 relevance if not specified
+      compileRelevance
+    ].forEach((ext) => ext(mode, parent));
+    mode.isCompiled = true;
+    let keywordPattern = null;
+    if (typeof mode.keywords === "object" && mode.keywords.$pattern) {
+      mode.keywords = Object.assign({}, mode.keywords);
+      keywordPattern = mode.keywords.$pattern;
+      delete mode.keywords.$pattern;
+    }
+    keywordPattern = keywordPattern || /\w+/;
+    if (mode.keywords) {
+      mode.keywords = compileKeywords(mode.keywords, language.case_insensitive);
+    }
+    cmode.keywordPatternRe = langRe(keywordPattern, true);
+    if (parent) {
+      if (!mode.begin) mode.begin = /\B|\b/;
+      cmode.beginRe = langRe(cmode.begin);
+      if (!mode.end && !mode.endsWithParent) mode.end = /\B|\b/;
+      if (mode.end) cmode.endRe = langRe(cmode.end);
+      cmode.terminatorEnd = source(cmode.end) || "";
+      if (mode.endsWithParent && parent.terminatorEnd) {
+        cmode.terminatorEnd += (mode.end ? "|" : "") + parent.terminatorEnd;
+      }
+    }
+    if (mode.illegal) cmode.illegalRe = langRe(
+      /** @type {RegExp | string} */
+      mode.illegal
+    );
+    if (!mode.contains) mode.contains = [];
+    mode.contains = [].concat(...mode.contains.map(function(c) {
+      return expandOrCloneMode(c === "self" ? mode : c);
+    }));
+    mode.contains.forEach(function(c) {
+      compileMode(
+        /** @type Mode */
+        c,
+        cmode
+      );
+    });
+    if (mode.starts) {
+      compileMode(mode.starts, parent);
+    }
+    cmode.matcher = buildModeRegex(cmode);
+    return cmode;
+  }
+  if (!language.compilerExtensions) language.compilerExtensions = [];
+  if (language.contains && language.contains.includes("self")) {
+    throw new Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.");
+  }
+  language.classNameAliases = inherit$1(language.classNameAliases || {});
+  return compileMode(
+    /** @type Mode */
+    language
+  );
+}
+function dependencyOnParent(mode) {
+  if (!mode) return false;
+  return mode.endsWithParent || dependencyOnParent(mode.starts);
+}
+function expandOrCloneMode(mode) {
+  if (mode.variants && !mode.cachedVariants) {
+    mode.cachedVariants = mode.variants.map(function(variant) {
+      return inherit$1(mode, { variants: null }, variant);
+    });
+  }
+  if (mode.cachedVariants) {
+    return mode.cachedVariants;
+  }
+  if (dependencyOnParent(mode)) {
+    return inherit$1(mode, { starts: mode.starts ? inherit$1(mode.starts) : null });
+  }
+  if (Object.isFrozen(mode)) {
+    return inherit$1(mode);
+  }
+  return mode;
+}
+var version = "11.10.0";
+var HTMLInjectionError = class extends Error {
+  constructor(reason, html) {
+    super(reason);
+    this.name = "HTMLInjectionError";
+    this.html = html;
+  }
+};
+var escape = escapeHTML;
+var inherit = inherit$1;
+var NO_MATCH = /* @__PURE__ */ Symbol("nomatch");
+var MAX_KEYWORD_HITS = 7;
+var HLJS = function(hljs) {
+  const languages = /* @__PURE__ */ Object.create(null);
+  const aliases = /* @__PURE__ */ Object.create(null);
+  const plugins = [];
+  let SAFE_MODE = true;
+  const LANGUAGE_NOT_FOUND = "Could not find the language '{}', did you forget to load/include a language module?";
+  const PLAINTEXT_LANGUAGE = { disableAutodetect: true, name: "Plain text", contains: [] };
+  let options = {
+    ignoreUnescapedHTML: false,
+    throwUnescapedHTML: false,
+    noHighlightRe: /^(no-?highlight)$/i,
+    languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i,
+    classPrefix: "hljs-",
+    cssSelector: "pre code",
+    languages: null,
+    // beta configuration options, subject to change, welcome to discuss
+    // https://github.com/highlightjs/highlight.js/issues/1086
+    __emitter: TokenTreeEmitter
+  };
+  function shouldNotHighlight(languageName) {
+    return options.noHighlightRe.test(languageName);
+  }
+  function blockLanguage(block) {
+    let classes = block.className + " ";
+    classes += block.parentNode ? block.parentNode.className : "";
+    const match = options.languageDetectRe.exec(classes);
+    if (match) {
+      const language = getLanguage(match[1]);
+      if (!language) {
+        warn2(LANGUAGE_NOT_FOUND.replace("{}", match[1]));
+        warn2("Falling back to no-highlight mode for this block.", block);
+      }
+      return language ? match[1] : "no-highlight";
+    }
+    return classes.split(/\s+/).find((_class) => shouldNotHighlight(_class) || getLanguage(_class));
+  }
+  function highlight2(codeOrLanguageName, optionsOrCode, ignoreIllegals) {
+    let code = "";
+    let languageName = "";
+    if (typeof optionsOrCode === "object") {
+      code = codeOrLanguageName;
+      ignoreIllegals = optionsOrCode.ignoreIllegals;
+      languageName = optionsOrCode.language;
+    } else {
+      deprecated("10.7.0", "highlight(lang, code, ...args) has been deprecated.");
+      deprecated("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277");
+      languageName = codeOrLanguageName;
+      code = optionsOrCode;
+    }
+    if (ignoreIllegals === void 0) {
+      ignoreIllegals = true;
+    }
+    const context = {
+      code,
+      language: languageName
+    };
+    fire("before:highlight", context);
+    const result = context.result ? context.result : _highlight(context.language, context.code, ignoreIllegals);
+    result.code = context.code;
+    fire("after:highlight", result);
+    return result;
+  }
+  function _highlight(languageName, codeToHighlight, ignoreIllegals, continuation) {
+    const keywordHits = /* @__PURE__ */ Object.create(null);
+    function keywordData(mode, matchText) {
+      return mode.keywords[matchText];
+    }
+    function processKeywords() {
+      if (!top.keywords) {
+        emitter.addText(modeBuffer);
+        return;
+      }
+      let lastIndex = 0;
+      top.keywordPatternRe.lastIndex = 0;
+      let match = top.keywordPatternRe.exec(modeBuffer);
+      let buf = "";
+      while (match) {
+        buf += modeBuffer.substring(lastIndex, match.index);
+        const word = language.case_insensitive ? match[0].toLowerCase() : match[0];
+        const data = keywordData(top, word);
+        if (data) {
+          const [kind, keywordRelevance] = data;
+          emitter.addText(buf);
+          buf = "";
+          keywordHits[word] = (keywordHits[word] || 0) + 1;
+          if (keywordHits[word] <= MAX_KEYWORD_HITS) relevance += keywordRelevance;
+          if (kind.startsWith("_")) {
+            buf += match[0];
+          } else {
+            const cssClass = language.classNameAliases[kind] || kind;
+            emitKeyword(match[0], cssClass);
+          }
+        } else {
+          buf += match[0];
+        }
+        lastIndex = top.keywordPatternRe.lastIndex;
+        match = top.keywordPatternRe.exec(modeBuffer);
+      }
+      buf += modeBuffer.substring(lastIndex);
+      emitter.addText(buf);
+    }
+    function processSubLanguage() {
+      if (modeBuffer === "") return;
+      let result2 = null;
+      if (typeof top.subLanguage === "string") {
+        if (!languages[top.subLanguage]) {
+          emitter.addText(modeBuffer);
+          return;
+        }
+        result2 = _highlight(top.subLanguage, modeBuffer, true, continuations[top.subLanguage]);
+        continuations[top.subLanguage] = /** @type {CompiledMode} */
+        result2._top;
+      } else {
+        result2 = highlightAuto(modeBuffer, top.subLanguage.length ? top.subLanguage : null);
+      }
+      if (top.relevance > 0) {
+        relevance += result2.relevance;
+      }
+      emitter.__addSublanguage(result2._emitter, result2.language);
+    }
+    function processBuffer() {
+      if (top.subLanguage != null) {
+        processSubLanguage();
+      } else {
+        processKeywords();
+      }
+      modeBuffer = "";
+    }
+    function emitKeyword(keyword, scope) {
+      if (keyword === "") return;
+      emitter.startScope(scope);
+      emitter.addText(keyword);
+      emitter.endScope();
+    }
+    function emitMultiClass(scope, match) {
+      let i = 1;
+      const max = match.length - 1;
+      while (i <= max) {
+        if (!scope._emit[i]) {
+          i++;
+          continue;
+        }
+        const klass = language.classNameAliases[scope[i]] || scope[i];
+        const text = match[i];
+        if (klass) {
+          emitKeyword(text, klass);
+        } else {
+          modeBuffer = text;
+          processKeywords();
+          modeBuffer = "";
+        }
+        i++;
+      }
+    }
+    function startNewMode(mode, match) {
+      if (mode.scope && typeof mode.scope === "string") {
+        emitter.openNode(language.classNameAliases[mode.scope] || mode.scope);
+      }
+      if (mode.beginScope) {
+        if (mode.beginScope._wrap) {
+          emitKeyword(modeBuffer, language.classNameAliases[mode.beginScope._wrap] || mode.beginScope._wrap);
+          modeBuffer = "";
+        } else if (mode.beginScope._multi) {
+          emitMultiClass(mode.beginScope, match);
+          modeBuffer = "";
+        }
+      }
+      top = Object.create(mode, { parent: { value: top } });
+      return top;
+    }
+    function endOfMode(mode, match, matchPlusRemainder) {
+      let matched = startsWith(mode.endRe, matchPlusRemainder);
+      if (matched) {
+        if (mode["on:end"]) {
+          const resp = new Response(mode);
+          mode["on:end"](match, resp);
+          if (resp.isMatchIgnored) matched = false;
+        }
+        if (matched) {
+          while (mode.endsParent && mode.parent) {
+            mode = mode.parent;
+          }
+          return mode;
+        }
+      }
+      if (mode.endsWithParent) {
+        return endOfMode(mode.parent, match, matchPlusRemainder);
+      }
+    }
+    function doIgnore(lexeme) {
+      if (top.matcher.regexIndex === 0) {
+        modeBuffer += lexeme[0];
+        return 1;
+      } else {
+        resumeScanAtSamePosition = true;
+        return 0;
+      }
+    }
+    function doBeginMatch(match) {
+      const lexeme = match[0];
+      const newMode = match.rule;
+      const resp = new Response(newMode);
+      const beforeCallbacks = [newMode.__beforeBegin, newMode["on:begin"]];
+      for (const cb of beforeCallbacks) {
+        if (!cb) continue;
+        cb(match, resp);
+        if (resp.isMatchIgnored) return doIgnore(lexeme);
+      }
+      if (newMode.skip) {
+        modeBuffer += lexeme;
+      } else {
+        if (newMode.excludeBegin) {
+          modeBuffer += lexeme;
+        }
+        processBuffer();
+        if (!newMode.returnBegin && !newMode.excludeBegin) {
+          modeBuffer = lexeme;
+        }
+      }
+      startNewMode(newMode, match);
+      return newMode.returnBegin ? 0 : lexeme.length;
+    }
+    function doEndMatch(match) {
+      const lexeme = match[0];
+      const matchPlusRemainder = codeToHighlight.substring(match.index);
+      const endMode = endOfMode(top, match, matchPlusRemainder);
+      if (!endMode) {
+        return NO_MATCH;
+      }
+      const origin = top;
+      if (top.endScope && top.endScope._wrap) {
+        processBuffer();
+        emitKeyword(lexeme, top.endScope._wrap);
+      } else if (top.endScope && top.endScope._multi) {
+        processBuffer();
+        emitMultiClass(top.endScope, match);
+      } else if (origin.skip) {
+        modeBuffer += lexeme;
+      } else {
+        if (!(origin.returnEnd || origin.excludeEnd)) {
+          modeBuffer += lexeme;
+        }
+        processBuffer();
+        if (origin.excludeEnd) {
+          modeBuffer = lexeme;
+        }
+      }
+      do {
+        if (top.scope) {
+          emitter.closeNode();
+        }
+        if (!top.skip && !top.subLanguage) {
+          relevance += top.relevance;
+        }
+        top = top.parent;
+      } while (top !== endMode.parent);
+      if (endMode.starts) {
+        startNewMode(endMode.starts, match);
+      }
+      return origin.returnEnd ? 0 : lexeme.length;
+    }
+    function processContinuations() {
+      const list = [];
+      for (let current = top; current !== language; current = current.parent) {
+        if (current.scope) {
+          list.unshift(current.scope);
+        }
+      }
+      list.forEach((item) => emitter.openNode(item));
+    }
+    let lastMatch = {};
+    function processLexeme(textBeforeMatch, match) {
+      const lexeme = match && match[0];
+      modeBuffer += textBeforeMatch;
+      if (lexeme == null) {
+        processBuffer();
+        return 0;
+      }
+      if (lastMatch.type === "begin" && match.type === "end" && lastMatch.index === match.index && lexeme === "") {
+        modeBuffer += codeToHighlight.slice(match.index, match.index + 1);
+        if (!SAFE_MODE) {
+          const err = new Error(`0 width match regex (${languageName})`);
+          err.languageName = languageName;
+          err.badRule = lastMatch.rule;
+          throw err;
+        }
+        return 1;
+      }
+      lastMatch = match;
+      if (match.type === "begin") {
+        return doBeginMatch(match);
+      } else if (match.type === "illegal" && !ignoreIllegals) {
+        const err = new Error('Illegal lexeme "' + lexeme + '" for mode "' + (top.scope || "<unnamed>") + '"');
+        err.mode = top;
+        throw err;
+      } else if (match.type === "end") {
+        const processed = doEndMatch(match);
+        if (processed !== NO_MATCH) {
+          return processed;
+        }
+      }
+      if (match.type === "illegal" && lexeme === "") {
+        return 1;
+      }
+      if (iterations > 1e5 && iterations > match.index * 3) {
+        const err = new Error("potential infinite loop, way more iterations than matches");
+        throw err;
+      }
+      modeBuffer += lexeme;
+      return lexeme.length;
+    }
+    const language = getLanguage(languageName);
+    if (!language) {
+      error(LANGUAGE_NOT_FOUND.replace("{}", languageName));
+      throw new Error('Unknown language: "' + languageName + '"');
+    }
+    const md = compileLanguage(language);
+    let result = "";
+    let top = continuation || md;
+    const continuations = {};
+    const emitter = new options.__emitter(options);
+    processContinuations();
+    let modeBuffer = "";
+    let relevance = 0;
+    let index = 0;
+    let iterations = 0;
+    let resumeScanAtSamePosition = false;
+    try {
+      if (!language.__emitTokens) {
+        top.matcher.considerAll();
+        for (; ; ) {
+          iterations++;
+          if (resumeScanAtSamePosition) {
+            resumeScanAtSamePosition = false;
+          } else {
+            top.matcher.considerAll();
+          }
+          top.matcher.lastIndex = index;
+          const match = top.matcher.exec(codeToHighlight);
+          if (!match) break;
+          const beforeMatch = codeToHighlight.substring(index, match.index);
+          const processedCount = processLexeme(beforeMatch, match);
+          index = match.index + processedCount;
+        }
+        processLexeme(codeToHighlight.substring(index));
+      } else {
+        language.__emitTokens(codeToHighlight, emitter);
+      }
+      emitter.finalize();
+      result = emitter.toHTML();
+      return {
+        language: languageName,
+        value: result,
+        relevance,
+        illegal: false,
+        _emitter: emitter,
+        _top: top
+      };
+    } catch (err) {
+      if (err.message && err.message.includes("Illegal")) {
+        return {
+          language: languageName,
+          value: escape(codeToHighlight),
+          illegal: true,
+          relevance: 0,
+          _illegalBy: {
+            message: err.message,
+            index,
+            context: codeToHighlight.slice(index - 100, index + 100),
+            mode: err.mode,
+            resultSoFar: result
+          },
+          _emitter: emitter
+        };
+      } else if (SAFE_MODE) {
+        return {
+          language: languageName,
+          value: escape(codeToHighlight),
+          illegal: false,
+          relevance: 0,
+          errorRaised: err,
+          _emitter: emitter,
+          _top: top
+        };
+      } else {
+        throw err;
+      }
+    }
+  }
+  function justTextHighlightResult(code) {
+    const result = {
+      value: escape(code),
+      illegal: false,
+      relevance: 0,
+      _top: PLAINTEXT_LANGUAGE,
+      _emitter: new options.__emitter(options)
+    };
+    result._emitter.addText(code);
+    return result;
+  }
+  function highlightAuto(code, languageSubset) {
+    languageSubset = languageSubset || options.languages || Object.keys(languages);
+    const plaintext = justTextHighlightResult(code);
+    const results = languageSubset.filter(getLanguage).filter(autoDetection).map(
+      (name) => _highlight(name, code, false)
+    );
+    results.unshift(plaintext);
+    const sorted = results.sort((a, b) => {
+      if (a.relevance !== b.relevance) return b.relevance - a.relevance;
+      if (a.language && b.language) {
+        if (getLanguage(a.language).supersetOf === b.language) {
+          return 1;
+        } else if (getLanguage(b.language).supersetOf === a.language) {
+          return -1;
+        }
+      }
+      return 0;
+    });
+    const [best, secondBest] = sorted;
+    const result = best;
+    result.secondBest = secondBest;
+    return result;
+  }
+  function updateClassName(element, currentLang, resultLang) {
+    const language = currentLang && aliases[currentLang] || resultLang;
+    element.classList.add("hljs");
+    element.classList.add(`language-${language}`);
+  }
+  function highlightElement(element) {
+    let node = null;
+    const language = blockLanguage(element);
+    if (shouldNotHighlight(language)) return;
+    fire(
+      "before:highlightElement",
+      { el: element, language }
+    );
+    if (element.dataset.highlighted) {
+      console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.", element);
+      return;
+    }
+    if (element.children.length > 0) {
+      if (!options.ignoreUnescapedHTML) {
+        console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk.");
+        console.warn("https://github.com/highlightjs/highlight.js/wiki/security");
+        console.warn("The element with unescaped HTML:");
+        console.warn(element);
+      }
+      if (options.throwUnescapedHTML) {
+        const err = new HTMLInjectionError(
+          "One of your code blocks includes unescaped HTML.",
+          element.innerHTML
+        );
+        throw err;
+      }
+    }
+    node = element;
+    const text = node.textContent;
+    const result = language ? highlight2(text, { language, ignoreIllegals: true }) : highlightAuto(text);
+    element.innerHTML = result.value;
+    element.dataset.highlighted = "yes";
+    updateClassName(element, language, result.language);
+    element.result = {
+      language: result.language,
+      // TODO: remove with version 11.0
+      re: result.relevance,
+      relevance: result.relevance
+    };
+    if (result.secondBest) {
+      element.secondBest = {
+        language: result.secondBest.language,
+        relevance: result.secondBest.relevance
+      };
+    }
+    fire("after:highlightElement", { el: element, result, text });
+  }
+  function configure(userOptions) {
+    options = inherit(options, userOptions);
+  }
+  const initHighlighting = () => {
+    highlightAll();
+    deprecated("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.");
+  };
+  function initHighlightingOnLoad() {
+    highlightAll();
+    deprecated("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.");
+  }
+  let wantsHighlight = false;
+  function highlightAll() {
+    if (document.readyState === "loading") {
+      wantsHighlight = true;
+      return;
+    }
+    const blocks = document.querySelectorAll(options.cssSelector);
+    blocks.forEach(highlightElement);
+  }
+  function boot() {
+    if (wantsHighlight) highlightAll();
+  }
+  if (typeof window !== "undefined" && window.addEventListener) {
+    window.addEventListener("DOMContentLoaded", boot, false);
+  }
+  function registerLanguage(languageName, languageDefinition) {
+    let lang = null;
+    try {
+      lang = languageDefinition(hljs);
+    } catch (error$1) {
+      error("Language definition for '{}' could not be registered.".replace("{}", languageName));
+      if (!SAFE_MODE) {
+        throw error$1;
+      } else {
+        error(error$1);
+      }
+      lang = PLAINTEXT_LANGUAGE;
+    }
+    if (!lang.name) lang.name = languageName;
+    languages[languageName] = lang;
+    lang.rawDefinition = languageDefinition.bind(null, hljs);
+    if (lang.aliases) {
+      registerAliases(lang.aliases, { languageName });
+    }
+  }
+  function unregisterLanguage(languageName) {
+    delete languages[languageName];
+    for (const alias of Object.keys(aliases)) {
+      if (aliases[alias] === languageName) {
+        delete aliases[alias];
+      }
+    }
+  }
+  function listLanguages() {
+    return Object.keys(languages);
+  }
+  function getLanguage(name) {
+    name = (name || "").toLowerCase();
+    return languages[name] || languages[aliases[name]];
+  }
+  function registerAliases(aliasList, { languageName }) {
+    if (typeof aliasList === "string") {
+      aliasList = [aliasList];
+    }
+    aliasList.forEach((alias) => {
+      aliases[alias.toLowerCase()] = languageName;
+    });
+  }
+  function autoDetection(name) {
+    const lang = getLanguage(name);
+    return lang && !lang.disableAutodetect;
+  }
+  function upgradePluginAPI(plugin) {
+    if (plugin["before:highlightBlock"] && !plugin["before:highlightElement"]) {
+      plugin["before:highlightElement"] = (data) => {
+        plugin["before:highlightBlock"](
+          Object.assign({ block: data.el }, data)
+        );
+      };
+    }
+    if (plugin["after:highlightBlock"] && !plugin["after:highlightElement"]) {
+      plugin["after:highlightElement"] = (data) => {
+        plugin["after:highlightBlock"](
+          Object.assign({ block: data.el }, data)
+        );
+      };
+    }
+  }
+  function addPlugin(plugin) {
+    upgradePluginAPI(plugin);
+    plugins.push(plugin);
+  }
+  function removePlugin(plugin) {
+    const index = plugins.indexOf(plugin);
+    if (index !== -1) {
+      plugins.splice(index, 1);
+    }
+  }
+  function fire(event, args) {
+    const cb = event;
+    plugins.forEach(function(plugin) {
+      if (plugin[cb]) {
+        plugin[cb](args);
+      }
+    });
+  }
+  function deprecateHighlightBlock(el) {
+    deprecated("10.7.0", "highlightBlock will be removed entirely in v12.0");
+    deprecated("10.7.0", "Please use highlightElement now.");
+    return highlightElement(el);
+  }
+  Object.assign(hljs, {
+    highlight: highlight2,
+    highlightAuto,
+    highlightAll,
+    highlightElement,
+    // TODO: Remove with v12 API
+    highlightBlock: deprecateHighlightBlock,
+    configure,
+    initHighlighting,
+    initHighlightingOnLoad,
+    registerLanguage,
+    unregisterLanguage,
+    listLanguages,
+    getLanguage,
+    registerAliases,
+    autoDetection,
+    inherit,
+    addPlugin,
+    removePlugin
+  });
+  hljs.debugMode = function() {
+    SAFE_MODE = false;
+  };
+  hljs.safeMode = function() {
+    SAFE_MODE = true;
+  };
+  hljs.versionString = version;
+  hljs.regex = {
+    concat,
+    lookahead,
+    either,
+    optional,
+    anyNumberOfTimes
+  };
+  for (const key in MODES) {
+    if (typeof MODES[key] === "object") {
+      deepFreeze(MODES[key]);
+    }
+  }
+  Object.assign(hljs, MODES);
+  return hljs;
+};
+var highlight = HLJS({});
+highlight.newInstance = () => HLJS({});
+var core = highlight;
+highlight.HighlightJS = highlight;
+highlight.default = highlight;
+var HighlightJS = /* @__PURE__ */ getDefaultExportFromCjs(core);
+function parseNodes(nodes, className = []) {
+  return nodes.map((node) => {
+    const classes = [...className, ...node.properties ? node.properties.className : []];
+    if (node.children) {
+      return parseNodes(node.children, classes);
+    }
+    return {
+      text: node.value,
+      classes
+    };
+  }).flat();
+}
+function getHighlightNodes(result) {
+  return result.value || result.children || [];
+}
+function registered(aliasOrLanguage) {
+  return Boolean(HighlightJS.getLanguage(aliasOrLanguage));
+}
+function getDecorations({ doc, name, lowlight: lowlight2, defaultLanguage }) {
+  const decorations = [];
+  findChildren(doc, (node) => node.type.name === name).forEach((block) => {
+    var _a;
+    let from = block.pos + 1;
+    const language = block.node.attrs.language || defaultLanguage;
+    const languages = lowlight2.listLanguages();
+    const nodes = language && (languages.includes(language) || registered(language) || ((_a = lowlight2.registered) === null || _a === void 0 ? void 0 : _a.call(lowlight2, language))) ? getHighlightNodes(lowlight2.highlight(language, block.node.textContent)) : getHighlightNodes(lowlight2.highlightAuto(block.node.textContent));
+    parseNodes(nodes).forEach((node) => {
+      const to = from + node.text.length;
+      if (node.classes.length) {
+        const decoration = Decoration2.inline(from, to, {
+          class: node.classes.join(" ")
+        });
+        decorations.push(decoration);
+      }
+      from = to;
+    });
+  });
+  return DecorationSet2.create(doc, decorations);
+}
+function isFunction(param) {
+  return typeof param === "function";
+}
+function LowlightPlugin({ name, lowlight: lowlight2, defaultLanguage }) {
+  if (!["highlight", "highlightAuto", "listLanguages"].every((api) => isFunction(lowlight2[api]))) {
+    throw Error("You should provide an instance of lowlight to use the code-block-lowlight extension");
+  }
+  const lowlightPlugin = new Plugin4({
+    key: new PluginKey4("lowlight"),
+    state: {
+      init: (_, { doc }) => getDecorations({
+        doc,
+        name,
+        lowlight: lowlight2,
+        defaultLanguage
+      }),
+      apply: (transaction, decorationSet, oldState, newState) => {
+        const oldNodeName = oldState.selection.$head.parent.type.name;
+        const newNodeName = newState.selection.$head.parent.type.name;
+        const oldNodes = findChildren(oldState.doc, (node) => node.type.name === name);
+        const newNodes = findChildren(newState.doc, (node) => node.type.name === name);
+        if (transaction.docChanged && ([oldNodeName, newNodeName].includes(name) || newNodes.length !== oldNodes.length || transaction.steps.some((step) => {
+          return (
+            // @ts-ignore
+            step.from !== void 0 && step.to !== void 0 && oldNodes.some((node) => {
+              return (
+                // @ts-ignore
+                node.pos >= step.from && node.pos + node.node.nodeSize <= step.to
+              );
+            })
+          );
+        }))) {
+          return getDecorations({
+            doc: transaction.doc,
+            name,
+            lowlight: lowlight2,
+            defaultLanguage
+          });
+        }
+        return decorationSet.map(transaction.mapping, transaction.doc);
+      }
+    },
+    props: {
+      decorations(state) {
+        return lowlightPlugin.getState(state);
+      }
+    }
+  });
+  return lowlightPlugin;
+}
+var CodeBlockLowlight = CodeBlock.extend({
+  addOptions() {
+    var _a;
+    return {
+      ...(_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this),
+      lowlight: {},
+      languageClassPrefix: "language-",
+      exitOnTripleEnter: true,
+      exitOnArrowDown: true,
+      defaultLanguage: null,
+      HTMLAttributes: {}
+    };
+  },
+  addProseMirrorPlugins() {
+    var _a;
+    return [
+      ...((_a = this.parent) === null || _a === void 0 ? void 0 : _a.call(this)) || [],
+      LowlightPlugin({
+        name: this.name,
+        lowlight: this.options.lowlight,
+        defaultLanguage: this.options.defaultLanguage
+      })
+    ];
+  }
+});
+
+// src/extensions/preset.ts
+import { common, createLowlight } from "lowlight";
+
 // ../../node_modules/.pnpm/@tiptap+extension-table-row@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2_/node_modules/@tiptap/extension-table-row/dist/index.js
 import { Node as Node15, mergeAttributes as mergeAttributes20 } from "@tiptap/core";
 var TableRow = Node15.create({
@@ -3641,14 +5305,6 @@ var TableHeader = Node18.create({
 });
 
 // src/extensions/table-formatting.ts
-var TABLE_CELL_BACKGROUND_PRESETS = {
-  none: null,
-  gray: "#f3f4f6",
-  yellow: "#fef3c7",
-  blue: "#dbeafe",
-  green: "#dcfce7",
-  red: "#fee2e2"
-};
 var LoomaTable = Table.configure({
   resizable: true,
   lastColumnResizable: false
@@ -3758,6 +5414,16 @@ function setActiveTableCellBackground(editor, backgroundColor) {
 }
 
 // src/extensions/preset.ts
+var lowlight = createLowlight(common);
+var LoomaTableKit = Extension7.create({
+  name: "loomaTableKit",
+  addExtensions() {
+    return [LoomaTable, TableRow, LoomaTableHeader, LoomaTableCell];
+  }
+});
+function getLoomaTableExtensions() {
+  return [LoomaTable, TableRow, LoomaTableHeader, LoomaTableCell];
+}
 function getDefaultEditorExtensions(options = {}) {
   const {
     placeholder = "Type \u201C/\u201D for commands, or start writing\u2026",
@@ -3791,22 +5457,103 @@ function getDefaultEditorExtensions(options = {}) {
     Image.configure({ inline: imageInline }),
     Highlight.configure({ multicolor: false }),
     Code,
-    CodeBlock,
+    CodeBlockLowlight.configure({ lowlight }),
     Typography,
     Placeholder.configure({
       placeholder: ({ node }) => node.type.name === "paragraph" ? placeholder : "",
       emptyNodeClass: "is-editor-empty"
     }),
-    LoomaTable,
-    TableRow,
-    LoomaTableHeader,
-    LoomaTableCell,
+    LoomaTableKit,
     LoomaListBehavior
   ];
 }
 
 // src/extensions/table-commands.ts
+import { TextSelection as TextSelection4 } from "@tiptap/pm/state";
 import { TableMap } from "@tiptap/pm/tables";
+var NO_TABLE_CAPABILITIES = {
+  canAddRowBefore: false,
+  canAddRowAfter: false,
+  canAddColumnBefore: false,
+  canAddColumnAfter: false,
+  canDeleteRow: false,
+  canDeleteColumn: false,
+  canDeleteTable: false,
+  canMergeCells: false,
+  canSplitCell: false
+};
+function shouldShowTextFormattingToolbar(editor, from = editor.state.selection.from, to = editor.state.selection.to) {
+  return editor.isEditable && editor.state.selection instanceof TextSelection4 && from !== to;
+}
+function getActiveTableUiState(editor) {
+  const active = editor.isActive("table");
+  if (!active) {
+    return {
+      active: false,
+      showToolbar: false,
+      cellAlignment: "left",
+      cellBackground: null,
+      capabilities: { ...NO_TABLE_CAPABILITIES }
+    };
+  }
+  return {
+    active: true,
+    showToolbar: true,
+    cellAlignment: getActiveTableCellAlignment(editor),
+    cellBackground: getActiveTableCellBackground(editor),
+    capabilities: {
+      canAddRowBefore: editor.can().addRowBefore(),
+      canAddRowAfter: editor.can().addRowAfter(),
+      canAddColumnBefore: editor.can().addColumnBefore(),
+      canAddColumnAfter: editor.can().addColumnAfter(),
+      canDeleteRow: editor.can().deleteRow(),
+      canDeleteColumn: editor.can().deleteColumn(),
+      canDeleteTable: editor.can().deleteTable(),
+      canMergeCells: editor.can().mergeCells(),
+      canSplitCell: editor.can().splitCell()
+    }
+  };
+}
+function handleTableAction(editor, detail) {
+  switch (detail.action) {
+    case "align-left":
+      return setActiveTableCellAlignment(editor, "left");
+    case "align-center":
+      return setActiveTableCellAlignment(editor, "center");
+    case "align-right":
+      return setActiveTableCellAlignment(editor, "right");
+    case "background-none":
+      return setActiveTableCellBackground(editor, TABLE_CELL_BACKGROUND_PRESETS.none);
+    case "background-gray":
+      return setActiveTableCellBackground(editor, TABLE_CELL_BACKGROUND_PRESETS.gray);
+    case "background-yellow":
+      return setActiveTableCellBackground(editor, TABLE_CELL_BACKGROUND_PRESETS.yellow);
+    case "background-blue":
+      return setActiveTableCellBackground(editor, TABLE_CELL_BACKGROUND_PRESETS.blue);
+    case "background-green":
+      return setActiveTableCellBackground(editor, TABLE_CELL_BACKGROUND_PRESETS.green);
+    case "background-red":
+      return setActiveTableCellBackground(editor, TABLE_CELL_BACKGROUND_PRESETS.red);
+    case "add-row-before":
+      return editor.chain().focus().addRowBefore().run();
+    case "add-row-after":
+      return editor.chain().focus().addRowAfter().run();
+    case "add-column-before":
+      return editor.chain().focus().addColumnBefore().run();
+    case "add-column-after":
+      return editor.chain().focus().addColumnAfter().run();
+    case "delete-row":
+      return editor.chain().focus().deleteRow().run();
+    case "delete-column":
+      return editor.chain().focus().deleteColumn().run();
+    case "delete-table":
+      return editor.chain().focus().deleteTable().run();
+    case "merge-cells":
+      return editor.chain().focus().mergeCells().run();
+    case "split-cell":
+      return editor.chain().focus().splitCell().run();
+  }
+}
 function arrayEquals(left, right) {
   if (!left || left.length !== right.length) {
     return false;
@@ -3968,7 +5715,7 @@ function handleTableOverlayAction(editor, detail) {
       break;
     }
     case "add-row-after": {
-      const rowIndex = Math.min(boundaryIndex, rows - 1);
+      const rowIndex = Math.min(boundaryIndex - 1, rows - 1);
       if (rowIndex < 0) return false;
       cellPos = getTextPositionInCell(tablePos, table, rowIndex, 0);
       command = () => editor.chain().focus().setTextSelection(cellPos).addRowAfter().run();
@@ -3982,7 +5729,7 @@ function handleTableOverlayAction(editor, detail) {
       break;
     }
     case "add-column-after": {
-      const colIndex = Math.min(boundaryIndex, cols - 1);
+      const colIndex = Math.min(boundaryIndex - 1, cols - 1);
       if (colIndex < 0) return false;
       cellPos = getTextPositionInCell(tablePos, table, 0, colIndex);
       command = () => editor.chain().focus().setTextSelection(cellPos).addColumnAfter().run();
@@ -3994,8 +5741,439 @@ function handleTableOverlayAction(editor, detail) {
   return command();
 }
 
+// src/extensions/slash-command.ts
+import { Extension as Extension8 } from "@tiptap/core";
+
+// ../../node_modules/.pnpm/@tiptap+suggestion@2.27.2_@tiptap+core@2.27.2_@tiptap+pm@2.27.2__@tiptap+pm@2.27.2/node_modules/@tiptap/suggestion/dist/index.js
+import { PluginKey as PluginKey5, Plugin as Plugin5 } from "@tiptap/pm/state";
+import { DecorationSet as DecorationSet3, Decoration as Decoration3 } from "@tiptap/pm/view";
+import { escapeForRegEx } from "@tiptap/core";
+function findSuggestionMatch(config) {
+  var _a;
+  const { char, allowSpaces: allowSpacesOption, allowToIncludeChar, allowedPrefixes, startOfLine, $position } = config;
+  const allowSpaces = allowSpacesOption && !allowToIncludeChar;
+  const escapedChar = escapeForRegEx(char);
+  const suffix = new RegExp(`\\s${escapedChar}$`);
+  const prefix = startOfLine ? "^" : "";
+  const finalEscapedChar = allowToIncludeChar ? "" : escapedChar;
+  const regexp = allowSpaces ? new RegExp(`${prefix}${escapedChar}.*?(?=\\s${finalEscapedChar}|$)`, "gm") : new RegExp(`${prefix}(?:^)?${escapedChar}[^\\s${finalEscapedChar}]*`, "gm");
+  const text = ((_a = $position.nodeBefore) === null || _a === void 0 ? void 0 : _a.isText) && $position.nodeBefore.text;
+  if (!text) {
+    return null;
+  }
+  const textFrom = $position.pos - text.length;
+  const match = Array.from(text.matchAll(regexp)).pop();
+  if (!match || match.input === void 0 || match.index === void 0) {
+    return null;
+  }
+  const matchPrefix = match.input.slice(Math.max(0, match.index - 1), match.index);
+  const matchPrefixIsAllowed = new RegExp(`^[${allowedPrefixes === null || allowedPrefixes === void 0 ? void 0 : allowedPrefixes.join("")}\0]?$`).test(matchPrefix);
+  if (allowedPrefixes !== null && !matchPrefixIsAllowed) {
+    return null;
+  }
+  const from = textFrom + match.index;
+  let to = from + match[0].length;
+  if (allowSpaces && suffix.test(text.slice(to - 1, to + 1))) {
+    match[0] += " ";
+    to += 1;
+  }
+  if (from < $position.pos && to >= $position.pos) {
+    return {
+      range: {
+        from,
+        to
+      },
+      query: match[0].slice(char.length),
+      text: match[0]
+    };
+  }
+  return null;
+}
+var SuggestionPluginKey = new PluginKey5("suggestion");
+function Suggestion({ pluginKey = SuggestionPluginKey, editor, char = "@", allowSpaces = false, allowToIncludeChar = false, allowedPrefixes = [" "], startOfLine = false, decorationTag = "span", decorationClass = "suggestion", decorationContent = "", decorationEmptyClass = "is-empty", command = () => null, items = () => [], render = () => ({}), allow = () => true, findSuggestionMatch: findSuggestionMatch$1 = findSuggestionMatch }) {
+  let props;
+  const renderer = render === null || render === void 0 ? void 0 : render();
+  const plugin = new Plugin5({
+    key: pluginKey,
+    view() {
+      return {
+        update: async (view, prevState) => {
+          var _a, _b, _c, _d, _e, _f, _g;
+          const prev = (_a = this.key) === null || _a === void 0 ? void 0 : _a.getState(prevState);
+          const next = (_b = this.key) === null || _b === void 0 ? void 0 : _b.getState(view.state);
+          const moved = prev.active && next.active && prev.range.from !== next.range.from;
+          const started = !prev.active && next.active;
+          const stopped = prev.active && !next.active;
+          const changed = !started && !stopped && prev.query !== next.query;
+          const handleStart = started || moved && changed;
+          const handleChange = changed || moved;
+          const handleExit = stopped || moved && changed;
+          if (!handleStart && !handleChange && !handleExit) {
+            return;
+          }
+          const state = handleExit && !handleStart ? prev : next;
+          const decorationNode = view.dom.querySelector(`[data-decoration-id="${state.decorationId}"]`);
+          props = {
+            editor,
+            range: state.range,
+            query: state.query,
+            text: state.text,
+            items: [],
+            command: (commandProps) => {
+              return command({
+                editor,
+                range: state.range,
+                props: commandProps
+              });
+            },
+            decorationNode,
+            // virtual node for popper.js or tippy.js
+            // this can be used for building popups without a DOM node
+            clientRect: decorationNode ? () => {
+              var _a2;
+              const { decorationId } = (_a2 = this.key) === null || _a2 === void 0 ? void 0 : _a2.getState(editor.state);
+              const currentDecorationNode = view.dom.querySelector(`[data-decoration-id="${decorationId}"]`);
+              return (currentDecorationNode === null || currentDecorationNode === void 0 ? void 0 : currentDecorationNode.getBoundingClientRect()) || null;
+            } : null
+          };
+          if (handleStart) {
+            (_c = renderer === null || renderer === void 0 ? void 0 : renderer.onBeforeStart) === null || _c === void 0 ? void 0 : _c.call(renderer, props);
+          }
+          if (handleChange) {
+            (_d = renderer === null || renderer === void 0 ? void 0 : renderer.onBeforeUpdate) === null || _d === void 0 ? void 0 : _d.call(renderer, props);
+          }
+          if (handleChange || handleStart) {
+            props.items = await items({
+              editor,
+              query: state.query
+            });
+          }
+          if (handleExit) {
+            (_e = renderer === null || renderer === void 0 ? void 0 : renderer.onExit) === null || _e === void 0 ? void 0 : _e.call(renderer, props);
+          }
+          if (handleChange) {
+            (_f = renderer === null || renderer === void 0 ? void 0 : renderer.onUpdate) === null || _f === void 0 ? void 0 : _f.call(renderer, props);
+          }
+          if (handleStart) {
+            (_g = renderer === null || renderer === void 0 ? void 0 : renderer.onStart) === null || _g === void 0 ? void 0 : _g.call(renderer, props);
+          }
+        },
+        destroy: () => {
+          var _a;
+          if (!props) {
+            return;
+          }
+          (_a = renderer === null || renderer === void 0 ? void 0 : renderer.onExit) === null || _a === void 0 ? void 0 : _a.call(renderer, props);
+        }
+      };
+    },
+    state: {
+      // Initialize the plugin's internal state.
+      init() {
+        const state = {
+          active: false,
+          range: {
+            from: 0,
+            to: 0
+          },
+          query: null,
+          text: null,
+          composing: false
+        };
+        return state;
+      },
+      // Apply changes to the plugin state from a view transaction.
+      apply(transaction, prev, _oldState, state) {
+        const { isEditable } = editor;
+        const { composing } = editor.view;
+        const { selection } = transaction;
+        const { empty, from } = selection;
+        const next = { ...prev };
+        next.composing = composing;
+        if (isEditable && (empty || editor.view.composing)) {
+          if ((from < prev.range.from || from > prev.range.to) && !composing && !prev.composing) {
+            next.active = false;
+          }
+          const match = findSuggestionMatch$1({
+            char,
+            allowSpaces,
+            allowToIncludeChar,
+            allowedPrefixes,
+            startOfLine,
+            $position: selection.$from
+          });
+          const decorationId = `id_${Math.floor(Math.random() * 4294967295)}`;
+          if (match && allow({
+            editor,
+            state,
+            range: match.range,
+            isActive: prev.active
+          })) {
+            next.active = true;
+            next.decorationId = prev.decorationId ? prev.decorationId : decorationId;
+            next.range = match.range;
+            next.query = match.query;
+            next.text = match.text;
+          } else {
+            next.active = false;
+          }
+        } else {
+          next.active = false;
+        }
+        if (!next.active) {
+          next.decorationId = null;
+          next.range = { from: 0, to: 0 };
+          next.query = null;
+          next.text = null;
+        }
+        return next;
+      }
+    },
+    props: {
+      // Call the keydown hook if suggestion is active.
+      handleKeyDown(view, event) {
+        var _a;
+        const { active, range } = plugin.getState(view.state);
+        if (!active) {
+          return false;
+        }
+        return ((_a = renderer === null || renderer === void 0 ? void 0 : renderer.onKeyDown) === null || _a === void 0 ? void 0 : _a.call(renderer, { view, event, range })) || false;
+      },
+      // Setup decorator on the currently active suggestion.
+      decorations(state) {
+        const { active, range, decorationId, query } = plugin.getState(state);
+        if (!active) {
+          return null;
+        }
+        const isEmpty = !(query === null || query === void 0 ? void 0 : query.length);
+        const classNames = [decorationClass];
+        if (isEmpty) {
+          classNames.push(decorationEmptyClass);
+        }
+        return DecorationSet3.create(state.doc, [
+          Decoration3.inline(range.from, range.to, {
+            nodeName: decorationTag,
+            class: classNames.join(" "),
+            "data-decoration-id": decorationId,
+            "data-decoration-content": decorationContent
+          })
+        ]);
+      }
+    }
+  });
+  return plugin;
+}
+
+// src/extensions/slash-command.ts
+function getDefaultSlashCommands(onOpenImagePicker) {
+  return [
+    {
+      title: "Text",
+      description: "Plain paragraph",
+      icon: "\xB6",
+      keywords: ["text", "paragraph", "plain", "p"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).setParagraph().run();
+      }
+    },
+    ...[1, 2, 3].map((level) => ({
+      title: `Heading ${level}`,
+      description: level === 1 ? "Big section title" : level === 2 ? "Medium section title" : "Small section title",
+      icon: `H${level}`,
+      keywords: [`h${level}`, "heading", "title"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).setHeading({ level }).run();
+      }
+    })),
+    {
+      title: "Bullet list",
+      description: "Unordered list",
+      icon: "\u2022",
+      keywords: ["bullet", "list", "ul", "unordered"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).toggleBulletList().run();
+      }
+    },
+    {
+      title: "Numbered list",
+      description: "Ordered list",
+      icon: "1.",
+      keywords: ["numbered", "ordered", "list", "ol"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).toggleOrderedList().run();
+      }
+    },
+    {
+      title: "Checklist",
+      description: "Interactive to-do items",
+      icon: "\u2611",
+      keywords: ["check", "task", "todo", "checklist"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).toggleTaskList().run();
+      }
+    },
+    {
+      title: "Blockquote",
+      description: "Highlighted quote",
+      icon: '"',
+      keywords: ["quote", "blockquote", "callout"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).toggleBlockquote().run();
+      }
+    },
+    {
+      title: "Inline code",
+      description: "Monospace code span",
+      icon: "`",
+      keywords: ["code", "inline", "monospace"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).toggleCode().run();
+      }
+    },
+    {
+      title: "Code block",
+      description: "Formatted code block",
+      icon: "<>",
+      keywords: ["codeblock", "pre", "syntax", "snippet"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).toggleCodeBlock().run();
+      }
+    },
+    {
+      title: "Table",
+      description: "Insert a table",
+      icon: "\u229E",
+      keywords: ["table", "grid", "rows", "columns"],
+      command: ({ editor, range }) => {
+        insertTableAtRange(editor, range);
+      }
+    },
+    {
+      title: "Divider",
+      description: "Horizontal rule",
+      icon: "\u2014",
+      keywords: ["divider", "hr", "rule", "line"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).setHorizontalRule().run();
+      }
+    },
+    {
+      title: "Image",
+      description: "Upload an image",
+      icon: "\u25A7",
+      keywords: ["image", "photo", "picture", "upload"],
+      command: ({ editor, range }) => {
+        editor.chain().focus().deleteRange(range).run();
+        onOpenImagePicker?.();
+      }
+    }
+  ];
+}
+var EMPTY_STATE = {
+  active: false,
+  items: [],
+  selectedIndex: 0,
+  query: "",
+  rect: null,
+  select: null
+};
+var LoomaSlashCommand = Extension8.create({
+  name: "loomaSlashCommand",
+  addOptions() {
+    return {
+      commands: getDefaultSlashCommands()
+    };
+  },
+  addProseMirrorPlugins() {
+    let selectedIndex = 0;
+    let currentProps = null;
+    const publish = (props) => {
+      if (!props) {
+        this.options.onStateChange?.({ ...EMPTY_STATE });
+        return;
+      }
+      this.options.onStateChange?.({
+        active: true,
+        items: props.items,
+        selectedIndex,
+        query: props.query,
+        rect: props.clientRect?.() ?? null,
+        select: (index) => {
+          const item = props.items[index];
+          if (item) props.command(item);
+        }
+      });
+    };
+    return [
+      Suggestion({
+        editor: this.editor,
+        char: "/",
+        allowSpaces: false,
+        startOfLine: false,
+        items: ({ query }) => {
+          const normalized = query.toLowerCase().trim();
+          const commands = this.options.commands.length > 0 ? this.options.commands : getDefaultSlashCommands(this.options.onOpenImagePicker);
+          if (!normalized) return commands;
+          return commands.filter(
+            (command) => command.title.toLowerCase().includes(normalized) || command.keywords.some((keyword) => keyword.includes(normalized))
+          );
+        },
+        command: ({ editor, range, props }) => {
+          props.command({ editor, range });
+        },
+        render: () => ({
+          onStart: (props) => {
+            currentProps = props;
+            selectedIndex = 0;
+            publish(props);
+          },
+          onUpdate: (props) => {
+            currentProps = props;
+            if (selectedIndex >= props.items.length) selectedIndex = 0;
+            publish(props);
+          },
+          onKeyDown: ({ event }) => {
+            if (!currentProps) return false;
+            if (event.key === "ArrowDown") {
+              selectedIndex = (selectedIndex + 1) % Math.max(1, currentProps.items.length);
+              publish(currentProps);
+              return true;
+            }
+            if (event.key === "ArrowUp") {
+              selectedIndex = (selectedIndex - 1 + currentProps.items.length) % Math.max(1, currentProps.items.length);
+              publish(currentProps);
+              return true;
+            }
+            if (event.key === "Enter") {
+              const item = currentProps.items[selectedIndex];
+              if (item) currentProps.command(item);
+              return true;
+            }
+            if (event.key === "Escape") {
+              currentProps = null;
+              publish(null);
+              return true;
+            }
+            return false;
+          },
+          onExit: () => {
+            currentProps = null;
+            publish(null);
+          }
+        })
+      })
+    ];
+  }
+});
+function createLoomaSlashCommandExtension(options = {}) {
+  const onOpenImagePicker = options.onOpenImagePicker;
+  return LoomaSlashCommand.configure({
+    ...options,
+    commands: options.commands ?? getDefaultSlashCommands(onOpenImagePicker)
+  });
+}
+
 export {
-  TABLE_CELL_BACKGROUND_PRESETS,
   LoomaTable,
   LoomaTableHeader,
   LoomaTableCell,
@@ -4003,8 +6181,16 @@ export {
   getActiveTableCellBackground,
   setActiveTableCellAlignment,
   setActiveTableCellBackground,
+  LoomaTableKit,
+  getLoomaTableExtensions,
   getDefaultEditorExtensions,
+  shouldShowTextFormattingToolbar,
+  getActiveTableUiState,
+  handleTableAction,
   insertTableAtRange,
   normalizeActiveTableColumnWidths,
-  handleTableOverlayAction
+  handleTableOverlayAction,
+  getDefaultSlashCommands,
+  LoomaSlashCommand,
+  createLoomaSlashCommandExtension
 };