@notectl/core 0.0.2

package/dist/notectl-core.js

@@ -0,0 +1,2205 @@
+class Xe {
+  constructor(t) {
+    this.nodes = new Map(t.nodes.map((e) => [e.type, e])), this.marks = new Map(t.marks.map((e) => [e.type, e])), this.topNode = t.topNode || "paragraph";
+  }
+  /**
+   * Get node specification
+   */
+  node(t) {
+    return this.nodes.get(t);
+  }
+  /**
+   * Get mark specification
+   */
+  mark(t) {
+    return this.marks.get(t);
+  }
+  /**
+   * Validate if a node conforms to the schema
+   */
+  validateNode(t) {
+    const e = [];
+    if ("text" in t) {
+      const i = t;
+      if (typeof i.text != "string" && e.push("Text node must have a string text property"), i.marks)
+        for (const o of i.marks)
+          this.marks.has(o.type) || e.push(`Unknown mark type: ${o.type}`);
+    } else {
+      const i = t, o = this.nodes.get(i.type);
+      if (!o)
+        return e.push(`Unknown node type: ${i.type}`), { valid: !1, errors: e };
+      if (o.attrs)
+        for (const [a, u] of Object.entries(o.attrs))
+          u.required && (!i.attrs || !(a in i.attrs)) && e.push(`Required attribute missing: ${a}`), i.attrs?.[a] && u.validate && (u.validate(i.attrs[a]) || e.push(`Invalid attribute value: ${a}`));
+      if (i.children)
+        for (const a of i.children) {
+          const u = this.validateNode(a);
+          e.push(...u.errors);
+        }
+    }
+    return {
+      valid: e.length === 0,
+      errors: e
+    };
+  }
+  /**
+   * Check if a mark is allowed on a node
+   */
+  markAllowedOn(t, e) {
+    const i = this.nodes.get(e);
+    return !i || !i.marks ? !1 : i.marks === "_" ? !0 : i.marks.split(" ").includes(t);
+  }
+  /**
+   * Check if two marks can coexist
+   */
+  marksCompatible(t, e) {
+    const i = this.marks.get(t), o = this.marks.get(e);
+    return !(i?.excludes && i.excludes.split(" ").includes(e) || o?.excludes && o.excludes.split(" ").includes(t));
+  }
+}
+function be() {
+  return new Xe({
+    nodes: [
+      {
+        type: "paragraph",
+        group: "block",
+        content: "inline*",
+        marks: "_"
+      },
+      {
+        type: "heading",
+        group: "block",
+        content: "inline*",
+        marks: "_",
+        attrs: {
+          level: {
+            default: 1,
+            validate: (r) => typeof r == "number" && r >= 1 && r <= 6
+          }
+        }
+      },
+      {
+        type: "list",
+        group: "block",
+        content: "list_item+"
+      },
+      {
+        type: "list_item",
+        content: "paragraph block*",
+        defining: !0
+      },
+      {
+        type: "table",
+        group: "block",
+        content: "table_row+",
+        isolating: !0
+      },
+      {
+        type: "table_row",
+        content: "table_cell+"
+      },
+      {
+        type: "table_cell",
+        content: "block+",
+        isolating: !0
+      },
+      {
+        type: "image",
+        group: "inline",
+        attrs: {
+          src: { required: !0 },
+          alt: { default: "" },
+          decorative: { default: !1 }
+        }
+      },
+      {
+        type: "code_block",
+        group: "block",
+        content: "text*",
+        marks: ""
+      },
+      {
+        type: "text",
+        group: "inline"
+      }
+    ],
+    marks: [
+      { type: "bold", excludes: "" },
+      { type: "italic", excludes: "" },
+      { type: "underline", excludes: "" },
+      { type: "strikethrough", excludes: "" },
+      { type: "code", excludes: "link" },
+      {
+        type: "link",
+        attrs: {
+          href: { required: !0 },
+          title: { default: "" }
+        },
+        excludes: "code"
+      }
+    ],
+    topNode: "paragraph"
+  });
+}
+function O() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (r) => {
+    const t = Math.random() * 16 | 0;
+    return (r === "x" ? t : t & 3 | 8).toString(16);
+  });
+}
+class qe {
+  constructor(t) {
+    this.schema = t;
+  }
+  /**
+   * Create a text node
+   */
+  text(t, e) {
+    return {
+      type: "text",
+      text: t,
+      marks: e || []
+    };
+  }
+  /**
+   * Create a paragraph node
+   */
+  paragraph(t, e) {
+    return {
+      id: O(),
+      type: "paragraph",
+      attrs: e,
+      children: t || []
+    };
+  }
+  /**
+   * Create a heading node
+   */
+  heading(t, e, i) {
+    return {
+      id: O(),
+      type: "heading",
+      attrs: { ...i, level: t },
+      children: e || []
+    };
+  }
+  /**
+   * Create a list node
+   */
+  list(t, e) {
+    return {
+      id: O(),
+      type: "list",
+      attrs: e,
+      children: t
+    };
+  }
+  /**
+   * Create a list item node
+   */
+  listItem(t, e) {
+    return {
+      id: O(),
+      type: "list_item",
+      attrs: e,
+      children: t
+    };
+  }
+  /**
+   * Create a table node
+   */
+  table(t, e) {
+    return {
+      id: O(),
+      type: "table",
+      attrs: e,
+      children: t
+    };
+  }
+  /**
+   * Create a table row node
+   */
+  tableRow(t, e) {
+    return {
+      id: O(),
+      type: "table_row",
+      attrs: e,
+      children: t
+    };
+  }
+  /**
+   * Create a table cell node
+   */
+  tableCell(t, e) {
+    return {
+      id: O(),
+      type: "table_cell",
+      attrs: e,
+      children: t
+    };
+  }
+  /**
+   * Create an image node
+   */
+  image(t, e, i) {
+    return {
+      id: O(),
+      type: "image",
+      attrs: { src: t, alt: e || "", decorative: !e, ...i },
+      children: []
+    };
+  }
+  /**
+   * Create a code block node
+   */
+  codeBlock(t, e) {
+    return {
+      id: O(),
+      type: "code_block",
+      attrs: e,
+      children: [this.text(t)]
+    };
+  }
+  /**
+   * Create a generic block node
+   */
+  block(t, e, i) {
+    if (!this.schema.node(t))
+      throw new Error(`Unknown node type: ${t}`);
+    return {
+      id: O(),
+      type: t,
+      attrs: e,
+      children: i
+    };
+  }
+  /**
+   * Create a mark
+   */
+  mark(t, e) {
+    if (!this.schema.mark(t))
+      throw new Error(`Unknown mark type: ${t}`);
+    return {
+      type: t,
+      attrs: e
+    };
+  }
+  /**
+   * Clone a node with new children
+   */
+  cloneNode(t, e) {
+    return {
+      ...t,
+      id: O(),
+      // Generate new ID for cloned node
+      children: e !== void 0 ? e : t.children
+    };
+  }
+}
+function Ze(r) {
+  return new qe(r);
+}
+class it {
+  constructor(t, e, i) {
+    this.selection = null, this.history = [], this.historyIndex = -1, this.schema = e || be(), this.nodeFactory = Ze(this.schema), this.maxHistoryDepth = i?.maxHistoryDepth || 100, this.document = t || {
+      version: 0,
+      schemaVersion: "1.0.0",
+      children: [this.nodeFactory.paragraph()]
+    };
+  }
+  /**
+   * Get current document
+   */
+  getDocument() {
+    return this.document;
+  }
+  /**
+   * Get document version
+   */
+  getVersion() {
+    return this.document.version;
+  }
+  /**
+   * Get current selection
+   */
+  getSelection() {
+    return this.selection;
+  }
+  /**
+   * Set selection
+   */
+  setSelection(t) {
+    this.selection = t;
+  }
+  /**
+   * Apply a delta to the state
+   */
+  applyDelta(t) {
+    if (t.baseVersion !== this.document.version)
+      throw new Error(
+        `Delta version mismatch: expected ${this.document.version}, got ${t.baseVersion}`
+      );
+    t.ops.some((i) => i.op !== "update_selection") && this.addToHistory(t);
+    for (const i of t.ops)
+      this.applyOperation(i);
+    this.document.version++;
+  }
+  /**
+   * Apply a single operation
+   */
+  applyOperation(t) {
+    switch (t.op) {
+      case "insert_text":
+        this.applyInsertText(t);
+        break;
+      case "delete_range":
+        this.applyDeleteRange(t);
+        break;
+      case "apply_mark":
+        this.applyMark(t);
+        break;
+      case "insert_block_after":
+        this.applyInsertBlockAfter(t);
+        break;
+      case "insert_block_before":
+        this.applyInsertBlockBefore(t);
+        break;
+      case "delete_block":
+        this.applyDeleteBlock(t);
+        break;
+      case "set_attrs":
+        this.applySetAttrs(t);
+        break;
+      case "update_selection":
+        this.selection = {
+          anchor: t.selection.anchor,
+          head: t.selection.head
+        };
+        break;
+      // Table operations would be implemented here
+      default:
+        console.warn("Unhandled operation type:", t.op);
+    }
+  }
+  /**
+   * Apply insert text operation
+   */
+  applyInsertText(t) {
+    const e = this.findBlock(t.target.blockId);
+    if (!e || !e.children) return;
+    const i = e.children.find((o) => "text" in o);
+    if (i) {
+      const o = i.text.slice(0, t.target.offset), a = i.text.slice(t.target.offset);
+      i.text = o + t.text + a, t.marks && t.marks.length > 0 && (i.marks = t.marks);
+    }
+  }
+  /**
+   * Apply delete range operation
+   */
+  applyDeleteRange(t) {
+    const e = this.findBlock(t.range.start.blockId);
+    if (!e || !e.children) return;
+    const i = e.children.find((o) => "text" in o);
+    if (i) {
+      const o = i.text.slice(0, t.range.start.offset), a = i.text.slice(t.range.end.offset);
+      i.text = o + a;
+    }
+  }
+  /**
+   * Apply mark operation
+   */
+  applyMark(t) {
+    const e = this.findBlock(t.range.start.blockId);
+    if (!e || !e.children) return;
+    const i = e.children.find((o) => "text" in o);
+    i && (t.add ? (i.marks = i.marks || [], i.marks.some((o) => o.type === t.mark.type) || i.marks.push(t.mark)) : i.marks = i.marks?.filter((o) => o.type !== t.mark.type));
+  }
+  /**
+   * Apply insert block after operation
+   */
+  applyInsertBlockAfter(t) {
+    const e = this.document.children.findIndex((i) => i.id === t.after);
+    e !== -1 && this.document.children.splice(e + 1, 0, t.block);
+  }
+  /**
+   * Apply insert block before operation
+   */
+  applyInsertBlockBefore(t) {
+    const e = this.document.children.findIndex((i) => i.id === t.before);
+    e !== -1 && this.document.children.splice(e, 0, t.block);
+  }
+  /**
+   * Apply delete block operation
+   */
+  applyDeleteBlock(t) {
+    const e = this.document.children.findIndex((i) => i.id === t.target.blockId);
+    e !== -1 && this.document.children.splice(e, 1);
+  }
+  /**
+   * Apply set attributes operation
+   */
+  applySetAttrs(t) {
+    const e = this.findBlock(t.target.blockId);
+    e && (e.attrs = { ...e.attrs, ...t.attrs });
+  }
+  /**
+   * Find a block by ID
+   */
+  findBlock(t) {
+    const e = (i) => {
+      for (const o of i) {
+        if (o.id === t)
+          return o;
+        if (o.children) {
+          const a = o.children.filter((h) => "id" in h), u = e(a);
+          if (u) return u;
+        }
+      }
+    };
+    return e(this.document.children);
+  }
+  /**
+   * Add delta to history
+   */
+  addToHistory(t) {
+    this.historyIndex < this.history.length - 1 && (this.history = this.history.slice(0, this.historyIndex + 1)), this.history.push({
+      delta: t,
+      inverseOps: t.inverseOps || [],
+      timestamp: Date.now()
+    }), this.history.length > this.maxHistoryDepth ? this.history.shift() : this.historyIndex++;
+  }
+  /**
+   * Undo last change
+   */
+  canUndo() {
+    return this.historyIndex >= 0;
+  }
+  undo() {
+    if (!this.canUndo()) return null;
+    const t = this.history[this.historyIndex];
+    return this.historyIndex--, {
+      txnId: `undo-${t.delta.txnId}`,
+      clientId: t.delta.clientId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      baseVersion: this.document.version,
+      ltime: Date.now(),
+      intent: "edit",
+      ops: t.inverseOps
+    };
+  }
+  /**
+   * Redo last undone change
+   */
+  canRedo() {
+    return this.historyIndex < this.history.length - 1;
+  }
+  redo() {
+    return this.canRedo() ? (this.historyIndex++, this.history[this.historyIndex].delta) : null;
+  }
+  /**
+   * Export state as JSON
+   */
+  toJSON() {
+    return this.document;
+  }
+  /**
+   * Create state from JSON
+   */
+  static fromJSON(t, e) {
+    return new it(t, e);
+  }
+}
+class Je {
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Map(), this.initializationOrder = [];
+  }
+  /**
+   * Register a plugin
+   */
+  async register(t, e) {
+    if (this.plugins.has(t.id))
+      throw new Error(`Plugin ${t.id} is already registered`);
+    if (t.dependencies) {
+      for (const i of t.dependencies)
+        if (!this.plugins.has(i))
+          throw new Error(`Plugin ${t.id} depends on ${i} which is not registered`);
+    }
+    await t.init(e), this.plugins.set(t.id, t), this.initializationOrder.push(t.id), e.emit("plugin-registered", { pluginId: t.id, plugin: t });
+  }
+  /**
+   * Unregister a plugin
+   */
+  async unregister(t, e) {
+    const i = this.plugins.get(t);
+    if (!i)
+      throw new Error(`Plugin ${t} is not registered`);
+    for (const [o, a] of this.plugins.entries())
+      if (a.dependencies?.includes(t))
+        throw new Error(`Cannot unregister ${t}: plugin ${o} depends on it`);
+    i.destroy && await i.destroy(), this.plugins.delete(t), this.initializationOrder = this.initializationOrder.filter((o) => o !== t), e.emit("plugin-unregistered", { pluginId: t });
+  }
+  /**
+   * Get a plugin by ID
+   */
+  get(t) {
+    return this.plugins.get(t);
+  }
+  /**
+   * Check if a plugin is registered
+   */
+  has(t) {
+    return this.plugins.has(t);
+  }
+  /**
+   * Get all registered plugins
+   */
+  getAll() {
+    return this.initializationOrder.map((t) => this.plugins.get(t));
+  }
+  /**
+   * Notify plugins of state update
+   */
+  notifyStateUpdate(t, e) {
+    for (const i of this.initializationOrder) {
+      const o = this.plugins.get(i);
+      if (o?.onStateUpdate)
+        try {
+          o.onStateUpdate(t, e);
+        } catch (a) {
+          console.error(`Error in plugin ${i} onStateUpdate:`, a);
+        }
+    }
+  }
+  /**
+   * Notify plugins of delta application
+   */
+  notifyDeltaApplied(t) {
+    for (const e of this.initializationOrder) {
+      const i = this.plugins.get(e);
+      if (i?.onDeltaApplied)
+        try {
+          i.onDeltaApplied(t);
+        } catch (o) {
+          console.error(`Error in plugin ${e} onDeltaApplied:`, o);
+        }
+    }
+  }
+  /**
+   * Destroy all plugins
+   */
+  async destroyAll() {
+    const t = [...this.initializationOrder].reverse();
+    for (const e of t) {
+      const i = this.plugins.get(e);
+      if (i?.destroy)
+        try {
+          await i.destroy();
+        } catch (o) {
+          console.error(`Error destroying plugin ${e}:`, o);
+        }
+    }
+    this.plugins.clear(), this.initializationOrder = [];
+  }
+}
+/*! @license DOMPurify 3.2.7 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.7/LICENSE */
+const {
+  entries: _e,
+  setPrototypeOf: he,
+  isFrozen: Qe,
+  getPrototypeOf: tn,
+  getOwnPropertyDescriptor: en
+} = Object;
+let {
+  freeze: k,
+  seal: w,
+  create: xe
+} = Object, {
+  apply: Ft,
+  construct: zt
+} = typeof Reflect < "u" && Reflect;
+k || (k = function(t) {
+  return t;
+});
+w || (w = function(t) {
+  return t;
+});
+Ft || (Ft = function(t, e) {
+  for (var i = arguments.length, o = new Array(i > 2 ? i - 2 : 0), a = 2; a < i; a++)
+    o[a - 2] = arguments[a];
+  return t.apply(e, o);
+});
+zt || (zt = function(t) {
+  for (var e = arguments.length, i = new Array(e > 1 ? e - 1 : 0), o = 1; o < e; o++)
+    i[o - 1] = arguments[o];
+  return new t(...i);
+});
+const mt = L(Array.prototype.forEach), nn = L(Array.prototype.lastIndexOf), fe = L(Array.prototype.pop), J = L(Array.prototype.push), rn = L(Array.prototype.splice), yt = L(String.prototype.toLowerCase), vt = L(String.prototype.toString), Dt = L(String.prototype.match), Q = L(String.prototype.replace), on = L(String.prototype.indexOf), sn = L(String.prototype.trim), N = L(Object.prototype.hasOwnProperty), A = L(RegExp.prototype.test), tt = an(TypeError);
+function L(r) {
+  return function(t) {
+    t instanceof RegExp && (t.lastIndex = 0);
+    for (var e = arguments.length, i = new Array(e > 1 ? e - 1 : 0), o = 1; o < e; o++)
+      i[o - 1] = arguments[o];
+    return Ft(r, t, i);
+  };
+}
+function an(r) {
+  return function() {
+    for (var t = arguments.length, e = new Array(t), i = 0; i < t; i++)
+      e[i] = arguments[i];
+    return zt(r, e);
+  };
+}
+function d(r, t) {
+  let e = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : yt;
+  he && he(r, null);
+  let i = t.length;
+  for (; i--; ) {
+    let o = t[i];
+    if (typeof o == "string") {
+      const a = e(o);
+      a !== o && (Qe(t) || (t[i] = a), o = a);
+    }
+    r[o] = !0;
+  }
+  return r;
+}
+function ln(r) {
+  for (let t = 0; t < r.length; t++)
+    N(r, t) || (r[t] = null);
+  return r;
+}
+function U(r) {
+  const t = xe(null);
+  for (const [e, i] of _e(r))
+    N(r, e) && (Array.isArray(i) ? t[e] = ln(i) : i && typeof i == "object" && i.constructor === Object ? t[e] = U(i) : t[e] = i);
+  return t;
+}
+function et(r, t) {
+  for (; r !== null; ) {
+    const i = en(r, t);
+    if (i) {
+      if (i.get)
+        return L(i.get);
+      if (typeof i.value == "function")
+        return L(i.value);
+    }
+    r = tn(r);
+  }
+  function e() {
+    return null;
+  }
+  return e;
+}
+const pe = k(["a", "abbr", "acronym", "address", "area", "article", "aside", "audio", "b", "bdi", "bdo", "big", "blink", "blockquote", "body", "br", "button", "canvas", "caption", "center", "cite", "code", "col", "colgroup", "content", "data", "datalist", "dd", "decorator", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "element", "em", "fieldset", "figcaption", "figure", "font", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "marquee", "menu", "menuitem", "meter", "nav", "nobr", "ol", "optgroup", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "search", "section", "select", "shadow", "slot", "small", "source", "spacer", "span", "strike", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "tr", "track", "tt", "u", "ul", "var", "video", "wbr"]), Mt = k(["svg", "a", "altglyph", "altglyphdef", "altglyphitem", "animatecolor", "animatemotion", "animatetransform", "circle", "clippath", "defs", "desc", "ellipse", "enterkeyhint", "exportparts", "filter", "font", "g", "glyph", "glyphref", "hkern", "image", "inputmode", "line", "lineargradient", "marker", "mask", "metadata", "mpath", "part", "path", "pattern", "polygon", "polyline", "radialgradient", "rect", "slot", "stop", "style", "switch", "symbol", "text", "textpath", "title", "tref", "tspan", "view", "vkern"]), Pt = k(["feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence"]), cn = k(["animate", "color-profile", "cursor", "discard", "font-face", "font-face-format", "font-face-name", "font-face-src", "font-face-uri", "foreignobject", "hatch", "hatchpath", "mesh", "meshgradient", "meshpatch", "meshrow", "missing-glyph", "script", "set", "solidcolor", "unknown", "use"]), Ut = k(["math", "menclose", "merror", "mfenced", "mfrac", "mglyph", "mi", "mlabeledtr", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msup", "msubsup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "mprescripts"]), dn = k(["maction", "maligngroup", "malignmark", "mlongdiv", "mscarries", "mscarry", "msgroup", "mstack", "msline", "msrow", "semantics", "annotation", "annotation-xml", "mprescripts", "none"]), me = k(["#text"]), ge = k(["accept", "action", "align", "alt", "autocapitalize", "autocomplete", "autopictureinpicture", "autoplay", "background", "bgcolor", "border", "capture", "cellpadding", "cellspacing", "checked", "cite", "class", "clear", "color", "cols", "colspan", "controls", "controlslist", "coords", "crossorigin", "datetime", "decoding", "default", "dir", "disabled", "disablepictureinpicture", "disableremoteplayback", "download", "draggable", "enctype", "enterkeyhint", "exportparts", "face", "for", "headers", "height", "hidden", "high", "href", "hreflang", "id", "inert", "inputmode", "integrity", "ismap", "kind", "label", "lang", "list", "loading", "loop", "low", "max", "maxlength", "media", "method", "min", "minlength", "multiple", "muted", "name", "nonce", "noshade", "novalidate", "nowrap", "open", "optimum", "part", "pattern", "placeholder", "playsinline", "popover", "popovertarget", "popovertargetaction", "poster", "preload", "pubdate", "radiogroup", "readonly", "rel", "required", "rev", "reversed", "role", "rows", "rowspan", "spellcheck", "scope", "selected", "shape", "size", "sizes", "slot", "span", "srclang", "start", "src", "srcset", "step", "style", "summary", "tabindex", "title", "translate", "type", "usemap", "valign", "value", "width", "wrap", "xmlns", "slot"]), Ht = k(["accent-height", "accumulate", "additive", "alignment-baseline", "amplitude", "ascent", "attributename", "attributetype", "azimuth", "basefrequency", "baseline-shift", "begin", "bias", "by", "class", "clip", "clippathunits", "clip-path", "clip-rule", "color", "color-interpolation", "color-interpolation-filters", "color-profile", "color-rendering", "cx", "cy", "d", "dx", "dy", "diffuseconstant", "direction", "display", "divisor", "dur", "edgemode", "elevation", "end", "exponent", "fill", "fill-opacity", "fill-rule", "filter", "filterunits", "flood-color", "flood-opacity", "font-family", "font-size", "font-size-adjust", "font-stretch", "font-style", "font-variant", "font-weight", "fx", "fy", "g1", "g2", "glyph-name", "glyphref", "gradientunits", "gradienttransform", "height", "href", "id", "image-rendering", "in", "in2", "intercept", "k", "k1", "k2", "k3", "k4", "kerning", "keypoints", "keysplines", "keytimes", "lang", "lengthadjust", "letter-spacing", "kernelmatrix", "kernelunitlength", "lighting-color", "local", "marker-end", "marker-mid", "marker-start", "markerheight", "markerunits", "markerwidth", "maskcontentunits", "maskunits", "max", "mask", "media", "method", "mode", "min", "name", "numoctaves", "offset", "operator", "opacity", "order", "orient", "orientation", "origin", "overflow", "paint-order", "path", "pathlength", "patterncontentunits", "patterntransform", "patternunits", "points", "preservealpha", "preserveaspectratio", "primitiveunits", "r", "rx", "ry", "radius", "refx", "refy", "repeatcount", "repeatdur", "restart", "result", "rotate", "scale", "seed", "shape-rendering", "slope", "specularconstant", "specularexponent", "spreadmethod", "startoffset", "stddeviation", "stitchtiles", "stop-color", "stop-opacity", "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin", "stroke-miterlimit", "stroke-opacity", "stroke", "stroke-width", "style", "surfacescale", "systemlanguage", "tabindex", "tablevalues", "targetx", "targety", "transform", "transform-origin", "text-anchor", "text-decoration", "text-rendering", "textlength", "type", "u1", "u2", "unicode", "values", "viewbox", "visibility", "version", "vert-adv-y", "vert-origin-x", "vert-origin-y", "width", "word-spacing", "wrap", "writing-mode", "xchannelselector", "ychannelselector", "x", "x1", "x2", "xmlns", "y", "y1", "y2", "z", "zoomandpan"]), ye = k(["accent", "accentunder", "align", "bevelled", "close", "columnsalign", "columnlines", "columnspan", "denomalign", "depth", "dir", "display", "displaystyle", "encoding", "fence", "frame", "height", "href", "id", "largeop", "length", "linethickness", "lspace", "lquote", "mathbackground", "mathcolor", "mathsize", "mathvariant", "maxsize", "minsize", "movablelimits", "notation", "numalign", "open", "rowalign", "rowlines", "rowspacing", "rowspan", "rspace", "rquote", "scriptlevel", "scriptminsize", "scriptsizemultiplier", "selection", "separator", "separators", "stretchy", "subscriptshift", "supscriptshift", "symmetric", "voffset", "width", "xmlns"]), gt = k(["xlink:href", "xml:id", "xlink:title", "xml:space", "xmlns:xlink"]), un = w(/\{\{[\w\W]*|[\w\W]*\}\}/gm), hn = w(/<%[\w\W]*|[\w\W]*%>/gm), fn = w(/\$\{[\w\W]*/gm), pn = w(/^data-[\-\w.\u00B7-\uFFFF]+$/), mn = w(/^aria-[\-\w]+$/), Se = w(
+  /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i
+  // eslint-disable-line no-useless-escape
+), gn = w(/^(?:\w+script|data):/i), yn = w(
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+  // eslint-disable-line no-control-regex
+), Ae = w(/^html$/i), En = w(/^[a-z][.\w]*(-[.\w]+)+$/i);
+var Ee = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  ARIA_ATTR: mn,
+  ATTR_WHITESPACE: yn,
+  CUSTOM_ELEMENT: En,
+  DATA_ATTR: pn,
+  DOCTYPE_NAME: Ae,
+  ERB_EXPR: hn,
+  IS_ALLOWED_URI: Se,
+  IS_SCRIPT_OR_DATA: gn,
+  MUSTACHE_EXPR: un,
+  TMPLIT_EXPR: fn
+});
+const nt = {
+  element: 1,
+  text: 3,
+  // Deprecated
+  progressingInstruction: 7,
+  comment: 8,
+  document: 9
+}, Tn = function() {
+  return typeof window > "u" ? null : window;
+}, bn = function(t, e) {
+  if (typeof t != "object" || typeof t.createPolicy != "function")
+    return null;
+  let i = null;
+  const o = "data-tt-policy-suffix";
+  e && e.hasAttribute(o) && (i = e.getAttribute(o));
+  const a = "dompurify" + (i ? "#" + i : "");
+  try {
+    return t.createPolicy(a, {
+      createHTML(u) {
+        return u;
+      },
+      createScriptURL(u) {
+        return u;
+      }
+    });
+  } catch {
+    return console.warn("TrustedTypes policy " + a + " could not be created."), null;
+  }
+}, Te = function() {
+  return {
+    afterSanitizeAttributes: [],
+    afterSanitizeElements: [],
+    afterSanitizeShadowDOM: [],
+    beforeSanitizeAttributes: [],
+    beforeSanitizeElements: [],
+    beforeSanitizeShadowDOM: [],
+    uponSanitizeAttribute: [],
+    uponSanitizeElement: [],
+    uponSanitizeShadowNode: []
+  };
+};
+function ke() {
+  let r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Tn();
+  const t = (c) => ke(c);
+  if (t.version = "3.2.7", t.removed = [], !r || !r.document || r.document.nodeType !== nt.document || !r.Element)
+    return t.isSupported = !1, t;
+  let {
+    document: e
+  } = r;
+  const i = e, o = i.currentScript, {
+    DocumentFragment: a,
+    HTMLTemplateElement: u,
+    Node: h,
+    Element: p,
+    NodeFilter: R,
+    NamedNodeMap: I = r.NamedNodeMap || r.MozNamedAttrMap,
+    HTMLFormElement: ot,
+    DOMParser: Ce,
+    trustedTypes: st
+  } = r, V = p.prototype, we = et(V, "cloneNode"), Ie = et(V, "remove"), Oe = et(V, "nextSibling"), Ne = et(V, "childNodes"), at = et(V, "parentNode");
+  if (typeof u == "function") {
+    const c = e.createElement("template");
+    c.content && c.content.ownerDocument && (e = c.content.ownerDocument);
+  }
+  let x, j = "";
+  const {
+    implementation: Et,
+    createNodeIterator: ve,
+    createDocumentFragment: De,
+    getElementsByTagName: Me
+  } = e, {
+    importNode: Pe
+  } = i;
+  let S = Te();
+  t.isSupported = typeof _e == "function" && typeof at == "function" && Et && Et.createHTMLDocument !== void 0;
+  const {
+    MUSTACHE_EXPR: Tt,
+    ERB_EXPR: bt,
+    TMPLIT_EXPR: _t,
+    DATA_ATTR: Ue,
+    ARIA_ATTR: He,
+    IS_SCRIPT_OR_DATA: Fe,
+    ATTR_WHITESPACE: $t,
+    CUSTOM_ELEMENT: ze
+  } = Ee;
+  let {
+    IS_ALLOWED_URI: Gt
+  } = Ee, y = null;
+  const Wt = d({}, [...pe, ...Mt, ...Pt, ...Ut, ...me]);
+  let T = null;
+  const Bt = d({}, [...ge, ...Ht, ...ye, ...gt]);
+  let m = Object.seal(xe(null, {
+    tagNameCheck: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: null
+    },
+    attributeNameCheck: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: null
+    },
+    allowCustomizedBuiltInElements: {
+      writable: !0,
+      configurable: !1,
+      enumerable: !0,
+      value: !1
+    }
+  })), X = null, xt = null, Kt = !0, St = !0, Yt = !1, Vt = !0, z = !1, lt = !0, H = !1, At = !1, kt = !1, $ = !1, ct = !1, dt = !1, jt = !0, Xt = !1;
+  const $e = "user-content-";
+  let Lt = !0, q = !1, G = {}, W = null;
+  const qt = d({}, ["annotation-xml", "audio", "colgroup", "desc", "foreignobject", "head", "iframe", "math", "mi", "mn", "mo", "ms", "mtext", "noembed", "noframes", "noscript", "plaintext", "script", "style", "svg", "template", "thead", "title", "video", "xmp"]);
+  let Zt = null;
+  const Jt = d({}, ["audio", "video", "img", "source", "image", "track"]);
+  let Rt = null;
+  const Qt = d({}, ["alt", "class", "for", "id", "label", "name", "pattern", "placeholder", "role", "summary", "title", "value", "style", "xmlns"]), ut = "http://www.w3.org/1998/Math/MathML", ht = "http://www.w3.org/2000/svg", D = "http://www.w3.org/1999/xhtml";
+  let B = D, Ct = !1, wt = null;
+  const Ge = d({}, [ut, ht, D], vt);
+  let ft = d({}, ["mi", "mo", "mn", "ms", "mtext"]), pt = d({}, ["annotation-xml"]);
+  const We = d({}, ["title", "style", "font", "a", "script"]);
+  let Z = null;
+  const Be = ["application/xhtml+xml", "text/html"], Ke = "text/html";
+  let E = null, K = null;
+  const Ye = e.createElement("form"), te = function(n) {
+    return n instanceof RegExp || n instanceof Function;
+  }, It = function() {
+    let n = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    if (!(K && K === n)) {
+      if ((!n || typeof n != "object") && (n = {}), n = U(n), Z = // eslint-disable-next-line unicorn/prefer-includes
+      Be.indexOf(n.PARSER_MEDIA_TYPE) === -1 ? Ke : n.PARSER_MEDIA_TYPE, E = Z === "application/xhtml+xml" ? vt : yt, y = N(n, "ALLOWED_TAGS") ? d({}, n.ALLOWED_TAGS, E) : Wt, T = N(n, "ALLOWED_ATTR") ? d({}, n.ALLOWED_ATTR, E) : Bt, wt = N(n, "ALLOWED_NAMESPACES") ? d({}, n.ALLOWED_NAMESPACES, vt) : Ge, Rt = N(n, "ADD_URI_SAFE_ATTR") ? d(U(Qt), n.ADD_URI_SAFE_ATTR, E) : Qt, Zt = N(n, "ADD_DATA_URI_TAGS") ? d(U(Jt), n.ADD_DATA_URI_TAGS, E) : Jt, W = N(n, "FORBID_CONTENTS") ? d({}, n.FORBID_CONTENTS, E) : qt, X = N(n, "FORBID_TAGS") ? d({}, n.FORBID_TAGS, E) : U({}), xt = N(n, "FORBID_ATTR") ? d({}, n.FORBID_ATTR, E) : U({}), G = N(n, "USE_PROFILES") ? n.USE_PROFILES : !1, Kt = n.ALLOW_ARIA_ATTR !== !1, St = n.ALLOW_DATA_ATTR !== !1, Yt = n.ALLOW_UNKNOWN_PROTOCOLS || !1, Vt = n.ALLOW_SELF_CLOSE_IN_ATTR !== !1, z = n.SAFE_FOR_TEMPLATES || !1, lt = n.SAFE_FOR_XML !== !1, H = n.WHOLE_DOCUMENT || !1, $ = n.RETURN_DOM || !1, ct = n.RETURN_DOM_FRAGMENT || !1, dt = n.RETURN_TRUSTED_TYPE || !1, kt = n.FORCE_BODY || !1, jt = n.SANITIZE_DOM !== !1, Xt = n.SANITIZE_NAMED_PROPS || !1, Lt = n.KEEP_CONTENT !== !1, q = n.IN_PLACE || !1, Gt = n.ALLOWED_URI_REGEXP || Se, B = n.NAMESPACE || D, ft = n.MATHML_TEXT_INTEGRATION_POINTS || ft, pt = n.HTML_INTEGRATION_POINTS || pt, m = n.CUSTOM_ELEMENT_HANDLING || {}, n.CUSTOM_ELEMENT_HANDLING && te(n.CUSTOM_ELEMENT_HANDLING.tagNameCheck) && (m.tagNameCheck = n.CUSTOM_ELEMENT_HANDLING.tagNameCheck), n.CUSTOM_ELEMENT_HANDLING && te(n.CUSTOM_ELEMENT_HANDLING.attributeNameCheck) && (m.attributeNameCheck = n.CUSTOM_ELEMENT_HANDLING.attributeNameCheck), n.CUSTOM_ELEMENT_HANDLING && typeof n.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements == "boolean" && (m.allowCustomizedBuiltInElements = n.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements), z && (St = !1), ct && ($ = !0), G && (y = d({}, me), T = [], G.html === !0 && (d(y, pe), d(T, ge)), G.svg === !0 && (d(y, Mt), d(T, Ht), d(T, gt)), G.svgFilters === !0 && (d(y, Pt), d(T, Ht), d(T, gt)), G.mathMl === !0 && (d(y, Ut), d(T, ye), d(T, gt))), n.ADD_TAGS && (y === Wt && (y = U(y)), d(y, n.ADD_TAGS, E)), n.ADD_ATTR && (T === Bt && (T = U(T)), d(T, n.ADD_ATTR, E)), n.ADD_URI_SAFE_ATTR && d(Rt, n.ADD_URI_SAFE_ATTR, E), n.FORBID_CONTENTS && (W === qt && (W = U(W)), d(W, n.FORBID_CONTENTS, E)), Lt && (y["#text"] = !0), H && d(y, ["html", "head", "body"]), y.table && (d(y, ["tbody"]), delete X.tbody), n.TRUSTED_TYPES_POLICY) {
+        if (typeof n.TRUSTED_TYPES_POLICY.createHTML != "function")
+          throw tt('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+        if (typeof n.TRUSTED_TYPES_POLICY.createScriptURL != "function")
+          throw tt('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+        x = n.TRUSTED_TYPES_POLICY, j = x.createHTML("");
+      } else
+        x === void 0 && (x = bn(st, o)), x !== null && typeof j == "string" && (j = x.createHTML(""));
+      k && k(n), K = n;
+    }
+  }, ee = d({}, [...Mt, ...Pt, ...cn]), ne = d({}, [...Ut, ...dn]), Ve = function(n) {
+    let s = at(n);
+    (!s || !s.tagName) && (s = {
+      namespaceURI: B,
+      tagName: "template"
+    });
+    const l = yt(n.tagName), f = yt(s.tagName);
+    return wt[n.namespaceURI] ? n.namespaceURI === ht ? s.namespaceURI === D ? l === "svg" : s.namespaceURI === ut ? l === "svg" && (f === "annotation-xml" || ft[f]) : !!ee[l] : n.namespaceURI === ut ? s.namespaceURI === D ? l === "math" : s.namespaceURI === ht ? l === "math" && pt[f] : !!ne[l] : n.namespaceURI === D ? s.namespaceURI === ht && !pt[f] || s.namespaceURI === ut && !ft[f] ? !1 : !ne[l] && (We[l] || !ee[l]) : !!(Z === "application/xhtml+xml" && wt[n.namespaceURI]) : !1;
+  }, v = function(n) {
+    J(t.removed, {
+      element: n
+    });
+    try {
+      at(n).removeChild(n);
+    } catch {
+      Ie(n);
+    }
+  }, F = function(n, s) {
+    try {
+      J(t.removed, {
+        attribute: s.getAttributeNode(n),
+        from: s
+      });
+    } catch {
+      J(t.removed, {
+        attribute: null,
+        from: s
+      });
+    }
+    if (s.removeAttribute(n), n === "is")
+      if ($ || ct)
+        try {
+          v(s);
+        } catch {
+        }
+      else
+        try {
+          s.setAttribute(n, "");
+        } catch {
+        }
+  }, ie = function(n) {
+    let s = null, l = null;
+    if (kt)
+      n = "<remove></remove>" + n;
+    else {
+      const g = Dt(n, /^[\r\n\t ]+/);
+      l = g && g[0];
+    }
+    Z === "application/xhtml+xml" && B === D && (n = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + n + "</body></html>");
+    const f = x ? x.createHTML(n) : n;
+    if (B === D)
+      try {
+        s = new Ce().parseFromString(f, Z);
+      } catch {
+      }
+    if (!s || !s.documentElement) {
+      s = Et.createDocument(B, "template", null);
+      try {
+        s.documentElement.innerHTML = Ct ? j : f;
+      } catch {
+      }
+    }
+    const _ = s.body || s.documentElement;
+    return n && l && _.insertBefore(e.createTextNode(l), _.childNodes[0] || null), B === D ? Me.call(s, H ? "html" : "body")[0] : H ? s.documentElement : _;
+  }, re = function(n) {
+    return ve.call(
+      n.ownerDocument || n,
+      n,
+      // eslint-disable-next-line no-bitwise
+      R.SHOW_ELEMENT | R.SHOW_COMMENT | R.SHOW_TEXT | R.SHOW_PROCESSING_INSTRUCTION | R.SHOW_CDATA_SECTION,
+      null
+    );
+  }, Ot = function(n) {
+    return n instanceof ot && (typeof n.nodeName != "string" || typeof n.textContent != "string" || typeof n.removeChild != "function" || !(n.attributes instanceof I) || typeof n.removeAttribute != "function" || typeof n.setAttribute != "function" || typeof n.namespaceURI != "string" || typeof n.insertBefore != "function" || typeof n.hasChildNodes != "function");
+  }, oe = function(n) {
+    return typeof h == "function" && n instanceof h;
+  };
+  function M(c, n, s) {
+    mt(c, (l) => {
+      l.call(t, n, s, K);
+    });
+  }
+  const se = function(n) {
+    let s = null;
+    if (M(S.beforeSanitizeElements, n, null), Ot(n))
+      return v(n), !0;
+    const l = E(n.nodeName);
+    if (M(S.uponSanitizeElement, n, {
+      tagName: l,
+      allowedTags: y
+    }), lt && n.hasChildNodes() && !oe(n.firstElementChild) && A(/<[/\w!]/g, n.innerHTML) && A(/<[/\w!]/g, n.textContent) || n.nodeType === nt.progressingInstruction || lt && n.nodeType === nt.comment && A(/<[/\w]/g, n.data))
+      return v(n), !0;
+    if (!y[l] || X[l]) {
+      if (!X[l] && le(l) && (m.tagNameCheck instanceof RegExp && A(m.tagNameCheck, l) || m.tagNameCheck instanceof Function && m.tagNameCheck(l)))
+        return !1;
+      if (Lt && !W[l]) {
+        const f = at(n) || n.parentNode, _ = Ne(n) || n.childNodes;
+        if (_ && f) {
+          const g = _.length;
+          for (let C = g - 1; C >= 0; --C) {
+            const P = we(_[C], !0);
+            P.__removalCount = (n.__removalCount || 0) + 1, f.insertBefore(P, Oe(n));
+          }
+        }
+      }
+      return v(n), !0;
+    }
+    return n instanceof p && !Ve(n) || (l === "noscript" || l === "noembed" || l === "noframes") && A(/<\/no(script|embed|frames)/i, n.innerHTML) ? (v(n), !0) : (z && n.nodeType === nt.text && (s = n.textContent, mt([Tt, bt, _t], (f) => {
+      s = Q(s, f, " ");
+    }), n.textContent !== s && (J(t.removed, {
+      element: n.cloneNode()
+    }), n.textContent = s)), M(S.afterSanitizeElements, n, null), !1);
+  }, ae = function(n, s, l) {
+    if (jt && (s === "id" || s === "name") && (l in e || l in Ye))
+      return !1;
+    if (!(St && !xt[s] && A(Ue, s))) {
+      if (!(Kt && A(He, s))) {
+        if (!T[s] || xt[s]) {
+          if (
+            // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+            // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+            // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+            !(le(n) && (m.tagNameCheck instanceof RegExp && A(m.tagNameCheck, n) || m.tagNameCheck instanceof Function && m.tagNameCheck(n)) && (m.attributeNameCheck instanceof RegExp && A(m.attributeNameCheck, s) || m.attributeNameCheck instanceof Function && m.attributeNameCheck(s, n)) || // Alternative, second condition checks if it's an `is`-attribute, AND
+            // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+            s === "is" && m.allowCustomizedBuiltInElements && (m.tagNameCheck instanceof RegExp && A(m.tagNameCheck, l) || m.tagNameCheck instanceof Function && m.tagNameCheck(l)))
+          ) return !1;
+        } else if (!Rt[s]) {
+          if (!A(Gt, Q(l, $t, ""))) {
+            if (!((s === "src" || s === "xlink:href" || s === "href") && n !== "script" && on(l, "data:") === 0 && Zt[n])) {
+              if (!(Yt && !A(Fe, Q(l, $t, "")))) {
+                if (l)
+                  return !1;
+              }
+            }
+          }
+        }
+      }
+    }
+    return !0;
+  }, le = function(n) {
+    return n !== "annotation-xml" && Dt(n, ze);
+  }, ce = function(n) {
+    M(S.beforeSanitizeAttributes, n, null);
+    const {
+      attributes: s
+    } = n;
+    if (!s || Ot(n))
+      return;
+    const l = {
+      attrName: "",
+      attrValue: "",
+      keepAttr: !0,
+      allowedAttributes: T,
+      forceKeepAttr: void 0
+    };
+    let f = s.length;
+    for (; f--; ) {
+      const _ = s[f], {
+        name: g,
+        namespaceURI: C,
+        value: P
+      } = _, Y = E(g), Nt = P;
+      let b = g === "value" ? Nt : sn(Nt);
+      if (l.attrName = Y, l.attrValue = b, l.keepAttr = !0, l.forceKeepAttr = void 0, M(S.uponSanitizeAttribute, n, l), b = l.attrValue, Xt && (Y === "id" || Y === "name") && (F(g, n), b = $e + b), lt && A(/((--!?|])>)|<\/(style|title|textarea)/i, b)) {
+        F(g, n);
+        continue;
+      }
+      if (Y === "attributename" && Dt(b, "href")) {
+        F(g, n);
+        continue;
+      }
+      if (l.forceKeepAttr)
+        continue;
+      if (!l.keepAttr) {
+        F(g, n);
+        continue;
+      }
+      if (!Vt && A(/\/>/i, b)) {
+        F(g, n);
+        continue;
+      }
+      z && mt([Tt, bt, _t], (ue) => {
+        b = Q(b, ue, " ");
+      });
+      const de = E(n.nodeName);
+      if (!ae(de, Y, b)) {
+        F(g, n);
+        continue;
+      }
+      if (x && typeof st == "object" && typeof st.getAttributeType == "function" && !C)
+        switch (st.getAttributeType(de, Y)) {
+          case "TrustedHTML": {
+            b = x.createHTML(b);
+            break;
+          }
+          case "TrustedScriptURL": {
+            b = x.createScriptURL(b);
+            break;
+          }
+        }
+      if (b !== Nt)
+        try {
+          C ? n.setAttributeNS(C, g, b) : n.setAttribute(g, b), Ot(n) ? v(n) : fe(t.removed);
+        } catch {
+          F(g, n);
+        }
+    }
+    M(S.afterSanitizeAttributes, n, null);
+  }, je = function c(n) {
+    let s = null;
+    const l = re(n);
+    for (M(S.beforeSanitizeShadowDOM, n, null); s = l.nextNode(); )
+      M(S.uponSanitizeShadowNode, s, null), se(s), ce(s), s.content instanceof a && c(s.content);
+    M(S.afterSanitizeShadowDOM, n, null);
+  };
+  return t.sanitize = function(c) {
+    let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, s = null, l = null, f = null, _ = null;
+    if (Ct = !c, Ct && (c = "<!-->"), typeof c != "string" && !oe(c))
+      if (typeof c.toString == "function") {
+        if (c = c.toString(), typeof c != "string")
+          throw tt("dirty is not a string, aborting");
+      } else
+        throw tt("toString is not a function");
+    if (!t.isSupported)
+      return c;
+    if (At || It(n), t.removed = [], typeof c == "string" && (q = !1), q) {
+      if (c.nodeName) {
+        const P = E(c.nodeName);
+        if (!y[P] || X[P])
+          throw tt("root node is forbidden and cannot be sanitized in-place");
+      }
+    } else if (c instanceof h)
+      s = ie("<!---->"), l = s.ownerDocument.importNode(c, !0), l.nodeType === nt.element && l.nodeName === "BODY" || l.nodeName === "HTML" ? s = l : s.appendChild(l);
+    else {
+      if (!$ && !z && !H && // eslint-disable-next-line unicorn/prefer-includes
+      c.indexOf("<") === -1)
+        return x && dt ? x.createHTML(c) : c;
+      if (s = ie(c), !s)
+        return $ ? null : dt ? j : "";
+    }
+    s && kt && v(s.firstChild);
+    const g = re(q ? c : s);
+    for (; f = g.nextNode(); )
+      se(f), ce(f), f.content instanceof a && je(f.content);
+    if (q)
+      return c;
+    if ($) {
+      if (ct)
+        for (_ = De.call(s.ownerDocument); s.firstChild; )
+          _.appendChild(s.firstChild);
+      else
+        _ = s;
+      return (T.shadowroot || T.shadowrootmode) && (_ = Pe.call(i, _, !0)), _;
+    }
+    let C = H ? s.outerHTML : s.innerHTML;
+    return H && y["!doctype"] && s.ownerDocument && s.ownerDocument.doctype && s.ownerDocument.doctype.name && A(Ae, s.ownerDocument.doctype.name) && (C = "<!DOCTYPE " + s.ownerDocument.doctype.name + `>
+` + C), z && mt([Tt, bt, _t], (P) => {
+      C = Q(C, P, " ");
+    }), x && dt ? x.createHTML(C) : C;
+  }, t.setConfig = function() {
+    let c = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    It(c), At = !0;
+  }, t.clearConfig = function() {
+    K = null, At = !1;
+  }, t.isValidAttribute = function(c, n, s) {
+    K || It({});
+    const l = E(c), f = E(n);
+    return ae(l, f, s);
+  }, t.addHook = function(c, n) {
+    typeof n == "function" && J(S[c], n);
+  }, t.removeHook = function(c, n) {
+    if (n !== void 0) {
+      const s = nn(S[c], n);
+      return s === -1 ? void 0 : rn(S[c], s, 1)[0];
+    }
+    return fe(S[c]);
+  }, t.removeHooks = function(c) {
+    S[c] = [];
+  }, t.removeAllHooks = function() {
+    S = Te();
+  }, t;
+}
+var _n = ke();
+const xn = {
+  ALLOWED_TAGS: [
+    "p",
+    "br",
+    "strong",
+    "em",
+    "u",
+    "s",
+    "code",
+    "pre",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "a",
+    "img",
+    "table",
+    "thead",
+    "tbody",
+    "tr",
+    "th",
+    "td",
+    "div",
+    "span"
+  ],
+  ALLOWED_ATTR: [
+    "href",
+    "src",
+    "alt",
+    "title",
+    "class",
+    "id",
+    "style",
+    "data-*",
+    "role",
+    "aria-*"
+  ],
+  ALLOWED_URI_REGEXP: /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i,
+  KEEP_CONTENT: !0,
+  SANITIZE_DOM: !0,
+  SAFE_FOR_TEMPLATES: !0
+}, Sn = {
+  ALLOWED_TAGS: ["p", "br", "strong", "em", "u", "code"],
+  ALLOWED_ATTR: [],
+  KEEP_CONTENT: !0,
+  SANITIZE_DOM: !0,
+  SAFE_FOR_TEMPLATES: !0
+};
+function rt(r, t = !1) {
+  const e = t ? Sn : xn;
+  return _n.sanitize(r, e);
+}
+function An(r, t = !0) {
+  return t ? rt(r) : kn(r);
+}
+function kn(r) {
+  const t = document.createElement("div");
+  return t.textContent = r, t.innerHTML;
+}
+function Ln(r) {
+  try {
+    if (!r || typeof r != "object" || !Array.isArray(r.ops))
+      return !1;
+    for (const t of r.ops) {
+      if ("insert" in t) {
+        const e = t.insert;
+        if (typeof e == "string" && rt(e) !== e && e.includes("<script"))
+          return !1;
+        if (typeof e == "object" && e !== null) {
+          const i = e;
+          if ("script" in i || "onerror" in i || "onclick" in i)
+            return !1;
+        }
+      }
+      if ("attributes" in t && t.attributes) {
+        const e = t.attributes;
+        for (const i in e)
+          if (i.startsWith("on") || i.toLowerCase().includes("script"))
+            return !1;
+      }
+    }
+    return !0;
+  } catch (t) {
+    return console.error("Error validating delta:", t), !1;
+  }
+}
+function Le(r, t = "polite") {
+  let e = document.getElementById("notectl-sr-live");
+  e ? e.setAttribute("aria-live", t) : (e = document.createElement("div"), e.id = "notectl-sr-live", e.setAttribute("role", "status"), e.setAttribute("aria-live", t), e.setAttribute("aria-atomic", "true"), e.style.position = "absolute", e.style.left = "-10000px", e.style.width = "1px", e.style.height = "1px", e.style.overflow = "hidden", document.body.appendChild(e)), e.textContent = "", setTimeout(() => {
+    e.textContent = r;
+  }, 100);
+}
+function Rn(r, t) {
+  const e = (i) => {
+    for (const o of r) {
+      const a = o.ctrlKey ? i.ctrlKey : !0, u = o.metaKey ? i.metaKey : !0, h = o.shiftKey ? i.shiftKey : !i.shiftKey, p = o.altKey ? i.altKey : !i.altKey;
+      if (i.key.toLowerCase() === o.key.toLowerCase() && a && u && h && p) {
+        i.preventDefault(), o.action(), Le(o.description);
+        break;
+      }
+    }
+  };
+  return t.addEventListener("keydown", e), () => {
+    t.removeEventListener("keydown", e);
+  };
+}
+function Cn(r, t) {
+  for (const [e, i] of Object.entries(t)) {
+    const o = e.startsWith("aria-") ? e : `aria-${e}`;
+    r.setAttribute(o, String(i));
+  }
+}
+class Re extends HTMLElement {
+  constructor() {
+    super(), this.eventListeners = /* @__PURE__ */ new Map(), this.commands = /* @__PURE__ */ new Map(), this.contentElement = null, this.pluginContainerTop = null, this.pluginContainerBottom = null, this.ariaLiveRegion = null, this.config = {
+      placeholder: "Start typing...",
+      readonly: !1,
+      autofocus: !1,
+      sanitizeHTML: !0,
+      maxHistoryDepth: 100
+    };
+    const t = be();
+    this.state = new it(void 0, t, {
+      maxHistoryDepth: this.config.maxHistoryDepth
+    }), this.pluginManager = new Je(), this.attachShadow({ mode: "open" });
+  }
+  /**
+   * Observed attributes for the web component
+   */
+  static get observedAttributes() {
+    return ["placeholder", "readonly", "autofocus"];
+  }
+  /**
+   * Called when element is connected to DOM
+   */
+  connectedCallback() {
+    this.render(), this.attachEventListeners(), this.setupAccessibility(), this.setupKeyboardShortcuts(), this.config.autofocus && this.focus();
+  }
+  /**
+   * Called when element is disconnected from DOM
+   */
+  disconnectedCallback() {
+    this.detachEventListeners(), this.pluginManager.destroyAll(), this.keyboardShortcutCleanup && this.keyboardShortcutCleanup(), this.ariaLiveRegion && this.ariaLiveRegion.parentNode && this.ariaLiveRegion.parentNode.removeChild(this.ariaLiveRegion);
+  }
+  /**
+   * Called when attributes change
+   */
+  attributeChangedCallback(t, e, i) {
+    if (e !== i)
+      switch (t) {
+        case "placeholder":
+          this.config.placeholder = i || "", this.updatePlaceholder();
+          break;
+        case "readonly":
+          this.config.readonly = i !== null, this.updateReadonly();
+          break;
+        case "autofocus":
+          this.config.autofocus = i !== null;
+          break;
+      }
+  }
+  /**
+   * Render the editor UI
+   */
+  render() {
+    this.shadowRoot && (this.shadowRoot.innerHTML = `
+      <style>
+        :host {
+          display: block;
+          position: relative;
+          font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+          font-size: 16px;
+          line-height: 1.5;
+        }
+
+        .notectl-container {
+          display: flex;
+          flex-direction: column;
+          border: 1px solid #e0e0e0;
+          border-radius: 4px;
+          background: white;
+        }
+
+        .notectl-plugin-container {
+          display: block;
+          background: transparent;
+        }
+
+        .notectl-plugin-container[data-position="top"] {
+          order: -1;
+        }
+
+        .notectl-plugin-container[data-position="bottom"] {
+          order: 1;
+        }
+
+        .notectl-editor-wrapper {
+          position: relative;
+          flex: 1;
+        }
+
+        .notectl-editor {
+          min-height: 200px;
+          padding: 1rem;
+          outline: none;
+          background: white;
+        }
+
+        .notectl-container:focus-within {
+          border-color: #2196F3;
+          box-shadow: 0 0 0 2px rgba(33, 150, 243, 0.1);
+        }
+
+        .notectl-editor[data-readonly="true"] {
+          background: #f5f5f5;
+          cursor: not-allowed;
+        }
+
+        .notectl-editor table {
+          border-collapse: collapse;
+          width: 100%;
+          margin: 1em 0;
+        }
+
+        .notectl-editor table td,
+        .notectl-editor table th {
+          border: 1px solid #ddd;
+          padding: 8px;
+          min-width: 100px;
+        }
+
+        .notectl-placeholder {
+          position: absolute;
+          top: 1rem;
+          left: 1rem;
+          color: #9e9e9e;
+          pointer-events: none;
+          user-select: none;
+        }
+
+        .notectl-placeholder.hidden {
+          display: none;
+        }
+
+        .visually-hidden {
+          position: absolute;
+          left: -10000px;
+          width: 1px;
+          height: 1px;
+          overflow: hidden;
+        }
+      </style>
+
+      <div class="notectl-container">
+        <div class="notectl-plugin-container" data-position="top"></div>
+        <div class="notectl-editor-wrapper">
+          <div class="notectl-placeholder" aria-hidden="true">${this.config.placeholder}</div>
+          <div
+            class="notectl-editor"
+            contenteditable="${!this.config.readonly}"
+            data-readonly="${this.config.readonly}"
+            role="textbox"
+            aria-label="Rich text editor"
+            aria-multiline="true"
+            aria-describedby="notectl-help-text"
+            tabindex="0"
+          ></div>
+        </div>
+        <div class="notectl-plugin-container" data-position="bottom"></div>
+      </div>
+      <div id="notectl-help-text" class="visually-hidden">
+        Use arrow keys to navigate. Press Ctrl+B for bold, Ctrl+I for italic, Ctrl+U for underline.
+        Press Ctrl+Z to undo, Ctrl+Shift+Z to redo.
+      </div>
+      <div id="notectl-aria-live" role="status" aria-live="polite" aria-atomic="true" class="visually-hidden"></div>
+    `, this.contentElement = this.shadowRoot.querySelector(".notectl-editor"), this.pluginContainerTop = this.shadowRoot.querySelector('.notectl-plugin-container[data-position="top"]'), this.pluginContainerBottom = this.shadowRoot.querySelector('.notectl-plugin-container[data-position="bottom"]'), this.ariaLiveRegion = this.shadowRoot.querySelector("#notectl-aria-live"), this.renderContent());
+  }
+  /**
+   * Render document content
+   */
+  renderContent() {
+    if (!this.contentElement) return;
+    const t = this.state.getDocument(), e = this.documentToHTML(t);
+    this.contentElement.innerHTML = this.config.sanitizeHTML ? rt(e) : e;
+  }
+  /**
+   * Convert document to HTML
+   */
+  documentToHTML(t) {
+    return t.children.map((e) => this.blockToHTML(e)).join("");
+  }
+  /**
+   * Convert block to HTML (simplified)
+   */
+  blockToHTML(t) {
+    switch (t.type) {
+      case "paragraph":
+        return `<p>${this.childrenToHTML(t.children || [])}</p>`;
+      case "heading":
+        const e = t.attrs?.level || 1;
+        return `<h${e}>${this.childrenToHTML(t.children || [])}</h${e}>`;
+      default:
+        return `<div>${this.childrenToHTML(t.children || [])}</div>`;
+    }
+  }
+  /**
+   * Convert children to HTML
+   */
+  childrenToHTML(t) {
+    return t.map((e) => {
+      if (e.type === "text") {
+        let i = this.escapeHTML(e.text);
+        if (e.marks)
+          for (const o of e.marks)
+            i = this.applyMarkHTML(i, o);
+        return i;
+      }
+      return this.blockToHTML(e);
+    }).join("");
+  }
+  /**
+   * Apply mark as HTML
+   */
+  applyMarkHTML(t, e) {
+    switch (e.type) {
+      case "bold":
+        return `<strong>${t}</strong>`;
+      case "italic":
+        return `<em>${t}</em>`;
+      case "underline":
+        return `<u>${t}</u>`;
+      case "strikethrough":
+        return `<s>${t}</s>`;
+      case "code":
+        return `<code>${t}</code>`;
+      default:
+        return t;
+    }
+  }
+  /**
+   * Escape HTML
+   */
+  escapeHTML(t) {
+    if (!this.config.sanitizeHTML) return t;
+    const e = document.createElement("div");
+    return e.textContent = t, e.innerHTML;
+  }
+  /**
+   * Setup accessibility features
+   */
+  setupAccessibility() {
+    this.contentElement && (Cn(this.contentElement, {
+      role: "textbox",
+      "aria-multiline": !0,
+      "aria-label": "Rich text editor",
+      "aria-describedby": "notectl-help-text",
+      "aria-autocomplete": "none"
+    }), this.config.readonly && this.contentElement.setAttribute("aria-readonly", "true"));
+  }
+  /**
+   * Setup keyboard shortcuts with screen reader announcements
+   */
+  setupKeyboardShortcuts() {
+    if (!this.contentElement) return;
+    const t = [
+      {
+        key: "b",
+        ctrlKey: !0,
+        description: "Bold formatting applied",
+        action: () => this.toggleFormat("bold")
+      },
+      {
+        key: "i",
+        ctrlKey: !0,
+        description: "Italic formatting applied",
+        action: () => this.toggleFormat("italic")
+      },
+      {
+        key: "u",
+        ctrlKey: !0,
+        description: "Underline formatting applied",
+        action: () => this.toggleFormat("underline")
+      },
+      {
+        key: "z",
+        ctrlKey: !0,
+        description: "Action undone",
+        action: () => this.undo()
+      },
+      {
+        key: "z",
+        ctrlKey: !0,
+        shiftKey: !0,
+        description: "Action redone",
+        action: () => this.redo()
+      }
+    ];
+    this.keyboardShortcutCleanup = Rn(t, this.contentElement);
+  }
+  /**
+   * Toggle formatting
+   */
+  toggleFormat(t) {
+    const e = window.getSelection();
+    if (!(!e || !this.contentElement))
+      try {
+        switch (t) {
+          case "bold":
+            document.execCommand("bold", !1);
+            break;
+          case "italic":
+            document.execCommand("italic", !1);
+            break;
+          case "underline":
+            document.execCommand("underline", !1);
+            break;
+          case "strikethrough":
+            document.execCommand("strikeThrough", !1);
+            break;
+          case "code":
+            const i = document.createElement("code");
+            if (e.rangeCount > 0) {
+              const o = e.getRangeAt(0);
+              i.appendChild(o.extractContents()), o.insertNode(i);
+            }
+            break;
+        }
+        this.announceToScreenReader(`${t} formatting applied`), this.emit("change", { state: this.state });
+      } catch (i) {
+        console.error(`Failed to apply ${t} formatting:`, i), this.announceToScreenReader(`Failed to apply ${t} formatting`);
+      }
+  }
+  /**
+   * Insert table at current selection
+   */
+  insertTable(t = 3, e = 3) {
+    if (this.contentElement)
+      try {
+        this.contentElement.focus();
+        const i = document.createElement("table");
+        i.setAttribute("data-notectl-table", "true");
+        const o = document.createElement("tbody");
+        for (let p = 0; p < t; p++) {
+          const R = document.createElement("tr");
+          for (let I = 0; I < e; I++) {
+            const ot = document.createElement("td");
+            ot.textContent = "", R.appendChild(ot);
+          }
+          o.appendChild(R);
+        }
+        i.appendChild(o);
+        const a = window.getSelection();
+        let u = this.contentElement.childNodes.length;
+        if (a && a.rangeCount > 0) {
+          const p = a.getRangeAt(0);
+          if (this.contentElement.contains(p.commonAncestorContainer)) {
+            let R = p.startContainer;
+            if (R.nodeType === Node.TEXT_NODE && (R = R.parentNode), R === this.contentElement)
+              u = p.startOffset;
+            else {
+              let I = R;
+              for (; I.parentNode && I.parentNode !== this.contentElement; )
+                I = I.parentNode;
+              I.parentNode === this.contentElement && (u = Array.from(this.contentElement.childNodes).indexOf(I) + 1);
+            }
+          }
+        }
+        const h = document.createElement("p");
+        if (h.innerHTML = "<br>", u >= this.contentElement.childNodes.length)
+          this.contentElement.appendChild(i), this.contentElement.appendChild(h);
+        else {
+          const p = this.contentElement.childNodes[u];
+          this.contentElement.insertBefore(i, p), this.contentElement.insertBefore(h, p);
+        }
+        if (a) {
+          const p = document.createRange();
+          p.setStart(h, 0), p.setEnd(h, 0), a.removeAllRanges(), a.addRange(p);
+        }
+        this.updatePlaceholder(), this.syncContentToState(), this.announceToScreenReader(`Table with ${t} rows and ${e} columns inserted`), this.emit("change", { state: this.state });
+      } catch (i) {
+        console.error("Failed to insert table:", i), this.announceToScreenReader("Failed to insert table");
+      }
+  }
+  /**
+   * Announce message to screen readers
+   */
+  announceToScreenReader(t) {
+    this.ariaLiveRegion ? (this.ariaLiveRegion.textContent = "", setTimeout(() => {
+      this.ariaLiveRegion && (this.ariaLiveRegion.textContent = t);
+    }, 100)) : Le(t);
+  }
+  /**
+   * Attach event listeners
+   */
+  attachEventListeners() {
+    this.contentElement && (this.contentElement.addEventListener("input", this.handleInput.bind(this)), this.contentElement.addEventListener("keydown", this.handleKeydown.bind(this)), this.contentElement.addEventListener("focus", this.handleFocus.bind(this)), this.contentElement.addEventListener("blur", this.handleBlur.bind(this)));
+  }
+  /**
+   * Detach event listeners
+   */
+  detachEventListeners() {
+    this.contentElement && (this.contentElement.removeEventListener("input", this.handleInput.bind(this)), this.contentElement.removeEventListener("keydown", this.handleKeydown.bind(this)), this.contentElement.removeEventListener("focus", this.handleFocus.bind(this)), this.contentElement.removeEventListener("blur", this.handleBlur.bind(this)));
+  }
+  /**
+   * Handle input event
+   */
+  handleInput(t) {
+    this.updatePlaceholder(), this.syncContentToState(), this.emit("change", { state: this.state });
+  }
+  /**
+   * Handle keydown event
+   */
+  handleKeydown(t) {
+    (t.ctrlKey || t.metaKey) && t.key === "z" && (t.preventDefault(), t.shiftKey ? (this.redo(), this.announceToScreenReader("Action redone")) : (this.undo(), this.announceToScreenReader("Action undone"))), ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(t.key) && (t.ctrlKey || t.metaKey) && this.announceToScreenReader(`Navigating ${t.key.replace("Arrow", "").toLowerCase()}`);
+  }
+  /**
+   * Handle focus event
+   */
+  handleFocus() {
+    this.emit("focus", { state: this.state });
+  }
+  /**
+   * Handle blur event
+   */
+  handleBlur() {
+    this.emit("blur", { state: this.state });
+  }
+  /**
+   * Update placeholder visibility
+   */
+  updatePlaceholder() {
+    if (!this.shadowRoot) return;
+    const t = this.shadowRoot.querySelector(".notectl-placeholder"), e = !this.contentElement?.textContent?.trim();
+    t && t.classList.toggle("hidden", !e);
+  }
+  /**
+   * Sync content from DOM to state
+   */
+  syncContentToState() {
+    if (this.contentElement)
+      try {
+        const t = this.htmlToDocument(this.contentElement.innerHTML);
+        this.state = it.fromJSON(t, this.state.schema);
+      } catch (t) {
+        console.error("Failed to sync content to state:", t);
+      }
+  }
+  /**
+   * Convert HTML to document structure
+   */
+  htmlToDocument(t) {
+    const o = new DOMParser().parseFromString(t, "text/html").body, a = [];
+    return Array.from(o.childNodes).forEach((u) => {
+      const h = this.nodeToBlock(u);
+      h && a.push(h);
+    }), a.length === 0 && a.push({
+      id: crypto.randomUUID(),
+      type: "paragraph",
+      children: []
+    }), {
+      version: this.state.getDocument().version + 1,
+      schemaVersion: "1.0.0",
+      children: a
+    };
+  }
+  /**
+   * Convert DOM node to block
+   */
+  nodeToBlock(t) {
+    if (t.nodeType === Node.TEXT_NODE) {
+      const e = t.textContent || "";
+      return e.trim() ? {
+        type: "text",
+        text: e,
+        marks: []
+      } : null;
+    }
+    if (t.nodeType === Node.ELEMENT_NODE) {
+      const e = t, i = e.tagName.toLowerCase();
+      if (i === "p")
+        return {
+          id: crypto.randomUUID(),
+          type: "paragraph",
+          children: this.parseChildren(e)
+        };
+      if (["h1", "h2", "h3", "h4", "h5", "h6"].includes(i)) {
+        const o = parseInt(i.charAt(1), 10);
+        return {
+          id: crypto.randomUUID(),
+          type: "heading",
+          attrs: { level: o },
+          children: this.parseChildren(e)
+        };
+      }
+      return this.parseInlineElement(e);
+    }
+    return null;
+  }
+  /**
+   * Parse children nodes
+   */
+  parseChildren(t) {
+    const e = [];
+    return Array.from(t.childNodes).forEach((i) => {
+      if (i.nodeType === Node.TEXT_NODE) {
+        const o = i.textContent || "";
+        o && e.push({
+          type: "text",
+          text: o,
+          marks: []
+        });
+      } else if (i.nodeType === Node.ELEMENT_NODE) {
+        const o = i, a = this.parseInlineElement(o);
+        a && (Array.isArray(a) ? e.push(...a) : e.push(a));
+      }
+    }), e;
+  }
+  /**
+   * Parse inline element with marks
+   */
+  parseInlineElement(t) {
+    const e = t.tagName.toLowerCase(), i = [];
+    e === "strong" || e === "b" ? i.push({ type: "bold" }) : e === "em" || e === "i" ? i.push({ type: "italic" }) : e === "u" ? i.push({ type: "underline" }) : e === "s" || e === "strike" ? i.push({ type: "strikethrough" }) : e === "code" && i.push({ type: "code" });
+    const o = [];
+    return Array.from(t.childNodes).forEach((a) => {
+      if (a.nodeType === Node.TEXT_NODE) {
+        const u = a.textContent || "";
+        u && o.push({
+          type: "text",
+          text: u,
+          marks: i
+        });
+      } else if (a.nodeType === Node.ELEMENT_NODE) {
+        const u = a, h = this.parseInlineElement(u);
+        h && (h.type === "text" ? (h.marks = [...i, ...h.marks || []], o.push(h)) : Array.isArray(h) && h.forEach((p) => {
+          p.type === "text" && (p.marks = [...i, ...p.marks || []]), o.push(p);
+        }));
+      }
+    }), o.length === 1 ? o[0] : o;
+  }
+  /**
+   * Update readonly state
+   */
+  updateReadonly() {
+    this.contentElement && (this.contentElement.contentEditable = String(!this.config.readonly), this.contentElement.setAttribute("data-readonly", String(this.config.readonly)));
+  }
+  /**
+   * Register a plugin
+   */
+  async registerPlugin(t) {
+    const e = this.createPluginContext();
+    await this.pluginManager.register(t, e);
+  }
+  /**
+   * Unregister a plugin
+   */
+  async unregisterPlugin(t) {
+    const e = this.createPluginContext();
+    await this.pluginManager.unregister(t, e);
+  }
+  /**
+   * Create plugin context
+   */
+  createPluginContext() {
+    return {
+      getState: () => this.state,
+      applyDelta: (t) => this.applyDelta(t),
+      on: (t, e) => this.on(t, e),
+      off: (t, e) => this.off(t, e),
+      emit: (t, e) => this.emit(t, e),
+      registerCommand: (t, e) => this.registerCommand(t, e),
+      executeCommand: (t, ...e) => this.executeCommand(t, ...e),
+      getContainer: () => this.contentElement,
+      getPluginContainer: (t) => t === "top" ? this.pluginContainerTop : this.pluginContainerBottom
+    };
+  }
+  /**
+   * Apply a delta
+   */
+  applyDelta(t) {
+    if (!Ln(t)) {
+      console.error("Invalid or unsafe delta rejected"), this.announceToScreenReader("Action blocked due to security validation");
+      return;
+    }
+    this.state.applyDelta(t), this.renderContent(), this.pluginManager.notifyDeltaApplied(t), this.emit("change", { delta: t, state: this.state });
+  }
+  /**
+   * Register event listener
+   */
+  on(t, e) {
+    this.eventListeners.has(t) || this.eventListeners.set(t, /* @__PURE__ */ new Set()), this.eventListeners.get(t).add(e);
+  }
+  /**
+   * Unregister event listener
+   */
+  off(t, e) {
+    this.eventListeners.get(t)?.delete(e);
+  }
+  /**
+   * Emit event
+   */
+  emit(t, e) {
+    this.eventListeners.get(t)?.forEach((i) => {
+      try {
+        i(e);
+      } catch (o) {
+        console.error(`Error in event listener for ${t}:`, o);
+      }
+    });
+  }
+  /**
+   * Register command
+   */
+  registerCommand(t, e) {
+    this.commands.set(t, e);
+  }
+  /**
+   * Execute command
+   */
+  executeCommand(t, ...e) {
+    const i = this.commands.get(t);
+    if (!i)
+      throw new Error(`Command not found: ${t}`);
+    return i(...e);
+  }
+  /**
+   * Undo last change
+   */
+  undo() {
+    const t = this.state.undo();
+    t ? (this.renderContent(), this.announceToScreenReader("Undo performed"), this.emit("change", { delta: t, state: this.state })) : this.announceToScreenReader("Nothing to undo");
+  }
+  /**
+   * Redo last undone change
+   */
+  redo() {
+    const t = this.state.redo();
+    t ? (this.renderContent(), this.announceToScreenReader("Redo performed"), this.emit("change", { delta: t, state: this.state })) : this.announceToScreenReader("Nothing to redo");
+  }
+  /**
+   * Configure editor options
+   * @param config - Configuration options to apply
+   */
+  configure(t) {
+    if (this.config = { ...this.config, ...t }, t.readonly !== void 0 && this.updateReadonly(), t.placeholder !== void 0 && this.shadowRoot) {
+      const e = this.shadowRoot.querySelector(".notectl-placeholder");
+      e && (e.textContent = t.placeholder);
+    }
+    t.initialContent && typeof t.initialContent == "object" && this.setJSON(t.initialContent), t.content && (typeof t.content == "string" ? this.setContent(t.content) : this.setJSON(t.content));
+  }
+  /**
+   * Destroy the editor and clean up resources
+   */
+  destroy() {
+    this.detachEventListeners(), this.pluginManager.destroyAll(), this.keyboardShortcutCleanup && this.keyboardShortcutCleanup(), this.ariaLiveRegion && this.ariaLiveRegion.parentNode && this.ariaLiveRegion.parentNode.removeChild(this.ariaLiveRegion), this.eventListeners.clear(), this.commands.clear();
+  }
+  /**
+   * Get current content as string or JSON
+   * @returns Current document content
+   */
+  getContent() {
+    return this.getJSON();
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get document as JSON
+   */
+  getJSON() {
+    return this.state.toJSON();
+  }
+  /**
+   * Set document from JSON
+   */
+  setJSON(t) {
+    this.state = it.fromJSON(t, this.state.schema), this.renderContent();
+  }
+  /**
+   * Get HTML content (sanitized)
+   */
+  getHTML() {
+    const t = this.documentToHTML(this.state.getDocument());
+    return this.config.sanitizeHTML ? rt(t) : t;
+  }
+  /**
+   * Set HTML content (with sanitization)
+   * @param html - HTML content to set
+   */
+  setHTML(t) {
+    const e = this.config.sanitizeHTML ? rt(t) : t;
+    this.contentElement && (this.contentElement.innerHTML = e, this.announceToScreenReader("Content updated"));
+  }
+  /**
+   * Set content from string (with sanitization)
+   * @param content - Content to set
+   * @param allowHTML - Allow HTML tags
+   */
+  setContent(t, e = !0) {
+    const i = this.config.sanitizeHTML ? An(t, e) : t;
+    this.contentElement && (this.contentElement.innerHTML = i, this.announceToScreenReader("Content updated"));
+  }
+  /**
+   * Export HTML content (sanitized)
+   * @returns Sanitized HTML
+   */
+  exportHTML() {
+    return this.getHTML();
+  }
+  /**
+   * Focus the editor
+   */
+  focus() {
+    this.contentElement?.focus();
+  }
+  /**
+   * Blur the editor
+   */
+  blur() {
+    this.contentElement?.blur();
+  }
+}
+customElements.get("notectl-editor") || customElements.define("notectl-editor", Re);
+class Mn {
+  async init(t) {
+    this.context = t;
+  }
+  async destroy() {
+    this.context = void 0;
+  }
+  getContext() {
+    if (!this.context)
+      throw new Error("Plugin not initialized");
+    return this.context;
+  }
+}
+class wn {
+  constructor(t, e) {
+    this.operations = [], this.delta = {
+      txnId: this.generateTxnId(),
+      clientId: t,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      baseVersion: e,
+      ltime: Date.now(),
+      ops: []
+    };
+  }
+  /**
+   * Set the intent of this delta
+   */
+  setIntent(t) {
+    return this.delta.intent = t, this;
+  }
+  /**
+   * Set the undo group for batch operations
+   */
+  setUndoGroup(t) {
+    return this.delta.undoGroup = t, this;
+  }
+  /**
+   * Add an operation to this delta
+   */
+  addOperation(t) {
+    return this.operations.push(t), this;
+  }
+  /**
+   * Add multiple operations
+   */
+  addOperations(t) {
+    return this.operations.push(...t), this;
+  }
+  /**
+   * Set inverse operations for fast undo
+   */
+  setInverseOps(t) {
+    return this.delta.inverseOps = t, this;
+  }
+  /**
+   * Set validation constraints
+   */
+  setValidation(t) {
+    return this.delta.validation = t, this;
+  }
+  /**
+   * Build the final delta
+   */
+  build() {
+    if (this.operations.length === 0)
+      throw new Error("Delta must contain at least one operation");
+    return {
+      ...this.delta,
+      ops: this.operations
+    };
+  }
+  /**
+   * Generate a unique transaction ID
+   */
+  generateTxnId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
+      const e = Math.random() * 16 | 0;
+      return (t === "x" ? e : e & 3 | 8).toString(16);
+    });
+  }
+}
+function Pn(r, t) {
+  return new wn(r, t);
+}
+function Un(r) {
+  return r.inverseOps || [];
+}
+function Hn(r) {
+  const t = [];
+  return r.txnId || t.push("Delta must have a transaction ID"), r.clientId || t.push("Delta must have a client ID"), r.ops.length === 0 && t.push("Delta must contain at least one operation"), r.baseVersion < 0 && t.push("Base version must be non-negative"), {
+    valid: t.length === 0,
+    errors: t
+  };
+}
+function Fn(r) {
+  return r.op === "insert_text" || r.op === "delete_range" || r.op === "apply_mark";
+}
+function zn(r) {
+  return r.op === "insert_block_before" || r.op === "insert_block_after" || r.op === "delete_block" || r.op === "set_attrs";
+}
+function $n(r) {
+  return r.op.startsWith("table_");
+}
+function Gn(r) {
+  return r.op === "update_selection";
+}
+function In(r, t, e) {
+  return r.op === "insert_text" && t.op === "insert_text" ? On(r, t, e) : r.op === "insert_text" && t.op === "delete_range" ? Nn(r, t) : r.op === "delete_range" && t.op === "insert_text" ? vn(r, t) : r.op === "delete_range" && t.op === "delete_range" ? Dn(r, t) : r;
+}
+function On(r, t, e) {
+  if (r.target.blockId === t.target.blockId) {
+    if (t.target.offset <= r.target.offset)
+      return {
+        ...r,
+        target: {
+          ...r.target,
+          offset: r.target.offset + t.text.length
+        }
+      };
+    if (t.target.offset === r.target.offset && e === "right")
+      return {
+        ...r,
+        target: {
+          ...r.target,
+          offset: r.target.offset + t.text.length
+        }
+      };
+  }
+  return r;
+}
+function Nn(r, t) {
+  if (r.target.blockId === t.range.start.blockId && r.target.offset >= t.range.start.offset) {
+    const e = t.range.end.offset - t.range.start.offset;
+    return {
+      ...r,
+      target: {
+        ...r.target,
+        offset: Math.max(t.range.start.offset, r.target.offset - e)
+      }
+    };
+  }
+  return r;
+}
+function vn(r, t) {
+  return r.range.start.blockId === t.target.blockId && t.target.offset <= r.range.start.offset ? {
+    ...r,
+    range: {
+      start: {
+        ...r.range.start,
+        offset: r.range.start.offset + t.text.length
+      },
+      end: {
+        ...r.range.end,
+        offset: r.range.end.offset + t.text.length
+      }
+    }
+  } : r;
+}
+function Dn(r, t, e) {
+  if (r.range.start.blockId === t.range.start.blockId) {
+    const i = r.range.start.offset, o = r.range.end.offset, a = t.range.start.offset, u = t.range.end.offset;
+    if (u <= i) {
+      const h = u - a;
+      return {
+        ...r,
+        range: {
+          start: { ...r.range.start, offset: i - h },
+          end: { ...r.range.end, offset: o - h }
+        }
+      };
+    }
+    if (a <= i && u >= o)
+      return {
+        ...r,
+        range: {
+          start: { ...r.range.start, offset: a },
+          end: { ...r.range.end, offset: a }
+        }
+      };
+  }
+  return r;
+}
+function Wn(r, t, e = "left") {
+  const i = r.ops.map((o) => {
+    let a = o;
+    for (const u of t.ops)
+      a = In(a, u, e);
+    return a;
+  });
+  return {
+    ...r,
+    ops: i,
+    baseVersion: t.baseVersion + 1
+    // Update to new base
+  };
+}
+function Bn(r, t) {
+  return {
+    ...t,
+    ops: [...r.ops, ...t.ops],
+    baseVersion: r.baseVersion
+  };
+}
+function Kn(r, t) {
+  return t.baseVersion === r.baseVersion || t.clientId === r.clientId;
+}
+function Yn(r, t) {
+  const e = new Re();
+  return r.appendChild(e), e;
+}
+const Vn = "0.0.1";
+export {
+  Mn as BasePlugin,
+  wn as DeltaBuilder,
+  it as EditorState,
+  qe as NodeFactory,
+  Re as NotectlEditor,
+  Je as PluginManager,
+  Xe as Schema,
+  Vn as VERSION,
+  Kn as canCompose,
+  Bn as composeDelta,
+  Un as computeInverse,
+  be as createDefaultSchema,
+  Pn as createDelta,
+  Yn as createEditor,
+  Ze as createNodeFactory,
+  O as generateBlockId,
+  zn as isBlockOperation,
+  Gn as isSelectionOperation,
+  $n as isTableOperation,
+  Fn as isTextOperation,
+  Wn as transformDelta,
+  In as transformOperation,
+  Hn as validateDelta
+};
+//# sourceMappingURL=notectl-core.js.map