@pixerate/editor 0.1.0

package/dist/index.js

@@ -0,0 +1,1082 @@
+// src/grammar/tokens.ts
+var TEMPLATE_REGEX = /{{\s*([^}]+?)\s*}}/g;
+var VARIABLE_REGEX = /(?<!\{)\{([^{}]+)\}(?!\})/g;
+var INSTRUCTION_REGEX = /__(.+?)__/g;
+var templateRegex = TEMPLATE_REGEX;
+var variableRegex = VARIABLE_REGEX;
+var instructionRegex = INSTRUCTION_REGEX;
+
+// src/grammar/tokenizer.ts
+function tokenizePrompt(text) {
+  if (!text) {
+    return [];
+  }
+  const rawMatches = [];
+  const tmplRegex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+  let match;
+  while ((match = tmplRegex.exec(text)) !== null) {
+    rawMatches.push({
+      type: "template",
+      raw: match[0],
+      value: match[1].trim(),
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  const varRegex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);
+  while ((match = varRegex.exec(text)) !== null) {
+    const start = match.index;
+    const end = start + match[0].length;
+    const overlaps = rawMatches.some(
+      (m) => !(end <= m.start || start >= m.end)
+    );
+    if (!overlaps) {
+      rawMatches.push({
+        type: "variable",
+        raw: match[0],
+        value: match[1].trim(),
+        start,
+        end
+      });
+    }
+  }
+  const instRegex = new RegExp(
+    INSTRUCTION_REGEX.source,
+    INSTRUCTION_REGEX.flags
+  );
+  while ((match = instRegex.exec(text)) !== null) {
+    const start = match.index;
+    const end = start + match[0].length;
+    const overlaps = rawMatches.some(
+      (m) => !(end <= m.start || start >= m.end)
+    );
+    if (!overlaps) {
+      rawMatches.push({
+        type: "instruction",
+        raw: match[0],
+        value: match[1].trim(),
+        start,
+        end
+      });
+    }
+  }
+  rawMatches.sort((a, b) => a.start - b.start);
+  const tokens = [];
+  let currentIdx = 0;
+  for (const m of rawMatches) {
+    if (m.start > currentIdx) {
+      const textChunk = text.slice(currentIdx, m.start);
+      tokens.push({
+        type: "text",
+        raw: textChunk,
+        value: textChunk,
+        start: currentIdx,
+        end: m.start
+      });
+    }
+    tokens.push({
+      type: m.type,
+      raw: m.raw,
+      value: m.value,
+      start: m.start,
+      end: m.end
+    });
+    currentIdx = m.end;
+  }
+  if (currentIdx < text.length) {
+    const textChunk = text.slice(currentIdx);
+    tokens.push({
+      type: "text",
+      raw: textChunk,
+      value: textChunk,
+      start: currentIdx,
+      end: text.length
+    });
+  }
+  return tokens;
+}
+
+// src/grammar/resolver.ts
+function getLatestVersion(template) {
+  if (!template.versions || template.versions.length === 0) {
+    if (template.body !== void 0) {
+      return {
+        id: template.id || "default",
+        version: "1.0",
+        body: template.body
+      };
+    }
+    return void 0;
+  }
+  if (template.latestVersion) {
+    const found = template.versions.find(
+      (v) => v.version === template.latestVersion
+    );
+    if (found) return found;
+  }
+  return template.versions[template.versions.length - 1];
+}
+function resolveTemplates(text, templates = [], options) {
+  const templateMap = /* @__PURE__ */ new Map();
+  for (const t of templates) {
+    templateMap.set(t.name, t);
+  }
+  const maxDepth = options?.maxDepth ?? 10;
+  function resolveRecursive(currentText, visited, depth) {
+    if (depth > maxDepth) {
+      return "[Template max depth exceeded]";
+    }
+    let result = currentText;
+    const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+    let match;
+    while ((match = regex.exec(result)) !== null) {
+      const [fullMatch, rawTemplateName] = match;
+      const templateName = rawTemplateName.trim();
+      if (visited.has(templateName)) {
+        return "[Template loop detected]";
+      }
+      const template = templateMap.get(templateName);
+      if (!template) {
+        continue;
+      }
+      let versionBody;
+      const boundVersionId = options?.bindings?.[templateName];
+      if (boundVersionId && template.versions) {
+        const boundVersion = template.versions.find(
+          (v) => v.id === boundVersionId || v.version === boundVersionId
+        );
+        versionBody = boundVersion?.body;
+      } else {
+        const latest = getLatestVersion(template);
+        versionBody = latest?.body ?? template.body;
+      }
+      if (versionBody === void 0) {
+        continue;
+      }
+      const nextVisited = new Set(visited);
+      nextVisited.add(templateName);
+      const resolvedBody = resolveRecursive(
+        versionBody,
+        nextVisited,
+        depth + 1
+      );
+      if (resolvedBody === "[Template loop detected]" || resolvedBody === "[Template max depth exceeded]") {
+        return resolvedBody;
+      }
+      result = result.replace(fullMatch, resolvedBody);
+      regex.lastIndex = 0;
+    }
+    return result;
+  }
+  return resolveRecursive(text, /* @__PURE__ */ new Set(), 0);
+}
+function resolveVariables(text, values) {
+  if (!text) return "";
+  return text.replace(
+    new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags),
+    (fullMatch, varName) => {
+      const key = varName.trim();
+      if (Object.prototype.hasOwnProperty.call(values, key)) {
+        return String(values[key]);
+      }
+      return fullMatch;
+    }
+  );
+}
+function extractTemplateNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+function extractVariableNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(VARIABLE_REGEX.source, VARIABLE_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+function extractInstructionNames(text) {
+  if (!text) return [];
+  const set = /* @__PURE__ */ new Set();
+  const regex = new RegExp(INSTRUCTION_REGEX.source, INSTRUCTION_REGEX.flags);
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    set.add(match[1].trim());
+  }
+  return Array.from(set);
+}
+
+// src/grammar/sourcemap.ts
+function resolveTemplatesWithMapping(text, templates = [], templateBindings) {
+  if (!templates || templates.length === 0 || !text.includes("{{")) {
+    return {
+      text,
+      map: [
+        {
+          resolvedStart: 0,
+          resolvedEnd: text.length,
+          source: "raw",
+          rawStart: 0,
+          rawEnd: text.length
+        }
+      ]
+    };
+  }
+  const templateMap = new Map(templates.map((t) => [t.name, t]));
+  const regex = /{{\s*([^}]+?)\s*}}/g;
+  let match;
+  let lastIndex = 0;
+  let resolvedText = "";
+  const map = [];
+  while ((match = regex.exec(text)) !== null) {
+    const [fullMatch, rawTemplateName] = match;
+    const templateName = rawTemplateName.trim();
+    const matchIndex = match.index;
+    if (matchIndex > lastIndex) {
+      const rawSegment = text.substring(lastIndex, matchIndex);
+      map.push({
+        resolvedStart: resolvedText.length,
+        resolvedEnd: resolvedText.length + rawSegment.length,
+        source: "raw",
+        rawStart: lastIndex,
+        rawEnd: matchIndex
+      });
+      resolvedText += rawSegment;
+    }
+    let resolvedBody = fullMatch;
+    let isTemplate = false;
+    if (templateMap.has(templateName)) {
+      const template = templateMap.get(templateName);
+      let versionBody;
+      const boundVersionId = templateBindings?.[templateName];
+      if (boundVersionId && template.versions) {
+        const boundVersion = template.versions.find(
+          (v) => v.id === boundVersionId || v.version === boundVersionId
+        );
+        versionBody = boundVersion?.body;
+      } else {
+        const latestVersion = getLatestVersion(template);
+        versionBody = latestVersion?.body ?? template.body;
+      }
+      if (versionBody !== void 0) {
+        resolvedBody = resolveTemplates(versionBody, templates, {
+          bindings: templateBindings
+        });
+        isTemplate = true;
+      }
+    }
+    if (isTemplate) {
+      map.push({
+        resolvedStart: resolvedText.length,
+        resolvedEnd: resolvedText.length + resolvedBody.length,
+        source: "template",
+        rawStart: matchIndex,
+        rawEnd: matchIndex + fullMatch.length,
+        templateName
+      });
+      resolvedText += resolvedBody;
+    } else {
+      map.push({
+        resolvedStart: resolvedText.length,
+        resolvedEnd: resolvedText.length + fullMatch.length,
+        source: "raw",
+        rawStart: matchIndex,
+        rawEnd: matchIndex + fullMatch.length
+      });
+      resolvedText += fullMatch;
+    }
+    lastIndex = matchIndex + fullMatch.length;
+  }
+  if (lastIndex < text.length) {
+    const rawSegment = text.substring(lastIndex);
+    map.push({
+      resolvedStart: resolvedText.length,
+      resolvedEnd: resolvedText.length + rawSegment.length,
+      source: "raw",
+      rawStart: lastIndex,
+      rawEnd: text.length
+    });
+    resolvedText += rawSegment;
+  }
+  return { text: resolvedText, map };
+}
+function mapResolvedOffsetToRaw(resolvedOffset, map) {
+  for (let i = 0; i < map.length; i++) {
+    const seg = map[i];
+    const isLast = i === map.length - 1;
+    const inRange = isLast ? resolvedOffset >= seg.resolvedStart && resolvedOffset <= seg.resolvedEnd : resolvedOffset >= seg.resolvedStart && resolvedOffset < seg.resolvedEnd;
+    if (inRange) {
+      if (seg.source === "raw") {
+        return seg.rawStart + (resolvedOffset - seg.resolvedStart);
+      } else {
+        return seg.rawStart;
+      }
+    }
+  }
+  return resolvedOffset;
+}
+function mapRawOffsetToResolved(rawOffset, map) {
+  for (let i = 0; i < map.length; i++) {
+    const seg = map[i];
+    const isLast = i === map.length - 1;
+    const inRange = isLast ? rawOffset >= seg.rawStart && rawOffset <= seg.rawEnd : rawOffset >= seg.rawStart && rawOffset < seg.rawEnd;
+    if (inRange) {
+      if (seg.source === "raw") {
+        return seg.resolvedStart + (rawOffset - seg.rawStart);
+      } else {
+        return seg.resolvedStart;
+      }
+    }
+  }
+  return rawOffset;
+}
+
+// src/extensions/gradient-text.ts
+import { Mark } from "@tiptap/core";
+import { Plugin } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+var createGradientDecorations = (doc, options) => {
+  const decorations = [];
+  const speed = options.speed ?? 1;
+  const jsonVarSet = options.jsonVariables ? options.jsonVariables instanceof Set ? options.jsonVariables : new Set(options.jsonVariables) : null;
+  doc.descendants((node, pos) => {
+    if (node.isText) {
+      const text = node.text || "";
+      let match;
+      const tmplRegex = new RegExp(TEMPLATE_REGEX.source, TEMPLATE_REGEX.flags);
+      while ((match = tmplRegex.exec(text)) !== null) {
+        const templateName = match[1].trim();
+        const colors = options.templateColorMap?.get(templateName);
+        if (colors) {
+          const start = pos + match.index;
+          const end = start + match[0].length;
+          const { from: colorFrom, to: colorTo } = colors;
+          const style = `--bg-size: ${speed * 300}%; --color-from: ${colorFrom}; --color-to: ${colorTo}; caret-color: #111 !important;`;
+          decorations.push(
+            Decoration.inline(start, end, {
+              class: "inline animate-gradient bg-gradient-to-r from-[var(--color-from)] via-[var(--color-to)] to-[var(--color-from)] bg-[length:var(--bg-size)_100%] bg-clip-text text-transparent border border-(--color-to)/20 px-1 py-0.5 rounded-sm cursor-pointer",
+              style,
+              "data-template": templateName
+            })
+          );
+        }
+      }
+      const instRegex = new RegExp(
+        INSTRUCTION_REGEX.source,
+        INSTRUCTION_REGEX.flags
+      );
+      while ((match = instRegex.exec(text)) !== null) {
+        const content = match[1].trim();
+        const colors = options.templateColorMap?.get(content) || {
+          from: "#ffaa40",
+          to: "#9c40ff"
+        };
+        const start = pos + match.index;
+        const end = start + match[0].length;
+        const { from: colorFrom, to: colorTo } = colors;
+        const style = `--bg-size: ${speed * 300}%; --color-from: ${colorFrom}; --color-to: ${colorTo}; caret-color: #111 !important;`;
+        decorations.push(
+          Decoration.inline(start, end, {
+            class: "italic animate-gradient bg-gradient-to-r from-rose-400 from-50% to-violet-500 to-50% bg-size-[200%_100%] bg-clip-text text-transparent inline-flex items-baseline gap-0.5",
+            style
+          })
+        );
+      }
+      const varRegex = new RegExp(
+        VARIABLE_REGEX.source,
+        VARIABLE_REGEX.flags
+      );
+      while ((match = varRegex.exec(text)) !== null) {
+        const variableName = match[1].trim();
+        const start = pos + match.index;
+        const end = start + match[0].length;
+        const isJsonVar = jsonVarSet?.has(variableName);
+        decorations.push(
+          Decoration.inline(start, end, {
+            class: isJsonVar ? "bg-violet-400/40 border-b-4 border-rose-300 dark:border-rose-800 inline-flex items-baseline px-1 py-0 text-foreground/80 gap-0.5 rounded-xs" : "bg-rose-400/40 border-b-4 border-violet-300 dark:border-violet-800 inline-flex items-baseline px-1 py-0 text-foreground/80 gap-0.5 rounded-xs",
+            "data-variable": variableName
+          })
+        );
+      }
+    }
+  });
+  return decorations;
+};
+var GradientText = Mark.create({
+  name: "gradientText",
+  addOptions() {
+    return {
+      templateColorMap: /* @__PURE__ */ new Map(),
+      speed: 1,
+      jsonVariables: void 0,
+      onTemplateClick: void 0
+    };
+  },
+  renderHTML({ HTMLAttributes }) {
+    const defaultColors = {
+      from: "#ffaa40",
+      to: "#9c40ff"
+    };
+    const speed = this.options.speed ?? 1;
+    const style = `--bg-size: ${speed * 300}%; --color-from: ${defaultColors.from}; --color-to: ${defaultColors.to}; caret-color: #111 !important;`;
+    return [
+      "span",
+      {
+        class: "inline animate-gradient bg-gradient-to-r from-[var(--color-from)] via-[var(--color-to)] to-[var(--color-from)] bg-[length:var(--bg-size)_100%] bg-clip-text text-transparent",
+        style,
+        ...HTMLAttributes
+      },
+      0
+    ];
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span",
+        getAttrs: (node) => node.classList.contains("animate-gradient") && node.classList.contains("bg-clip-text") && null
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    const markOptions = this.options;
+    return [
+      new Plugin({
+        state: {
+          init(_, { doc }) {
+            return DecorationSet.create(
+              doc,
+              createGradientDecorations(doc, markOptions)
+            );
+          },
+          apply(tr, value) {
+            const newDoc = tr.doc;
+            if (tr.docChanged) {
+              return DecorationSet.create(
+                newDoc,
+                createGradientDecorations(newDoc, markOptions)
+              );
+            }
+            return value.map(tr.mapping, newDoc);
+          }
+        },
+        props: {
+          decorations(state) {
+            return this.getState(state);
+          },
+          handleClickOn(view, pos, _node, _nodePos, event) {
+            const decorationSet = this.getState(
+              view.state
+            );
+            const decorations = decorationSet.find(pos, pos + 1);
+            for (const decoration of decorations) {
+              const decorationWithAttrs = decoration;
+              const templateName = decorationWithAttrs.type?.attrs?.["data-template"];
+              if (templateName) {
+                if (markOptions.onTemplateClick) {
+                  markOptions.onTemplateClick(templateName, event);
+                }
+                if (typeof window !== "undefined") {
+                  window.dispatchEvent(
+                    new CustomEvent("show-gradient-popover", {
+                      detail: {
+                        templateName,
+                        target: event.target
+                      }
+                    })
+                  );
+                }
+                return true;
+              }
+            }
+            return false;
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/slash-commands.ts
+import { Extension } from "@tiptap/core";
+import { Plugin as Plugin2 } from "@tiptap/pm/state";
+var SlashCommands = Extension.create({
+  name: "slashCommands",
+  addOptions() {
+    return {
+      trigger: "/",
+      onMatch: void 0,
+      onClear: void 0,
+      containerId: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const opts = this.options;
+    return [
+      new Plugin2({
+        view() {
+          return {
+            update(view) {
+              const { state } = view;
+              const { selection } = state;
+              const { $from } = selection;
+              if (!$from.parent.isTextblock) {
+                opts.onClear?.();
+                return;
+              }
+              const textBeforeCursor = $from.parent.textBetween(
+                0,
+                $from.parentOffset
+              );
+              const slashMatch = textBeforeCursor.match(
+                /(?:^|\s)\/([a-zA-Z0-9_-]*)$/
+              );
+              if (slashMatch) {
+                const matchIndex = slashMatch.index ?? 0;
+                const offsetInParent = matchIndex + (slashMatch[0].startsWith(" ") ? 1 : 0);
+                const matchFrom = $from.start() + offsetInParent;
+                const matchTo = $from.pos;
+                const coords = view.coordsAtPos($from.pos);
+                let relativeCoords = {
+                  top: coords.top,
+                  left: coords.left,
+                  bottom: coords.bottom,
+                  right: coords.right
+                };
+                if (opts.containerId && typeof document !== "undefined") {
+                  const container = document.getElementById(opts.containerId);
+                  if (container) {
+                    const rect = container.getBoundingClientRect();
+                    relativeCoords = {
+                      top: coords.bottom - rect.top + 5,
+                      left: coords.left - rect.left,
+                      bottom: coords.bottom - rect.top,
+                      right: coords.right - rect.left
+                    };
+                  }
+                }
+                opts.onMatch?.({
+                  match: slashMatch,
+                  query: slashMatch[1] || "",
+                  from: matchFrom,
+                  to: matchTo,
+                  coords: relativeCoords
+                });
+              } else {
+                opts.onClear?.();
+              }
+            }
+          };
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/template-suggestions.ts
+import { Extension as Extension2 } from "@tiptap/core";
+import Suggestion from "@tiptap/suggestion";
+var TemplateSuggestions = Extension2.create({
+  name: "templateSuggestions",
+  addOptions() {
+    return {
+      templates: [],
+      char: "{{",
+      onSuggestion: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    const opts = this.options;
+    const suggestionConfig = {
+      char: opts.char || "{{",
+      items: ({ query }) => {
+        const lower = query.toLowerCase();
+        return (opts.templates || []).filter(
+          (t) => t.name.toLowerCase().includes(lower)
+        );
+      },
+      command: ({ editor, range, props }) => {
+        editor.chain().focus().deleteRange(range).insertContent(`{{${props.name}}}`).run();
+      },
+      render: () => {
+        return {
+          onStart: (props) => {
+            opts.onSuggestion?.(props);
+          },
+          onUpdate: (props) => {
+            opts.onSuggestion?.(props);
+          },
+          onExit: () => {
+            opts.onSuggestion?.({
+              query: "",
+              range: { from: 0, to: 0 },
+              items: [],
+              command: () => {
+              }
+            });
+          }
+        };
+      }
+    };
+    return [
+      Suggestion({
+        editor: this.editor,
+        ...suggestionConfig
+      })
+    ];
+  }
+});
+
+// src/extensions/loading-node.ts
+import { Node, mergeAttributes } from "@tiptap/core";
+var LoadingNode = Node.create({
+  name: "loadingNode",
+  group: "inline",
+  inline: true,
+  selectable: true,
+  atom: true,
+  addAttributes() {
+    return {
+      id: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("data-id"),
+        renderHTML: (attributes) => {
+          if (!attributes.id) return {};
+          return { "data-id": attributes.id };
+        }
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: 'span[data-type="loading"]'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes(HTMLAttributes, {
+        "data-type": "loading",
+        class: "inline-flex items-center px-1.5 py-0.5 text-xs text-muted-foreground animate-pulse"
+      }),
+      "\u23F3"
+    ];
+  }
+});
+
+// src/extensions/SmilieReplacer.ts
+import { Extension as Extension3, textInputRule } from "@tiptap/core";
+var SmilieReplacer = Extension3.create({
+  name: "smilieReplacer",
+  addInputRules() {
+    return [
+      textInputRule({ find: /-___- $/, replace: "\u{1F611} " }),
+      textInputRule({ find: /:'-\) $/, replace: "\u{1F602} " }),
+      textInputRule({ find: /':-\) $/, replace: "\u{1F605} " }),
+      textInputRule({ find: /':-D $/, replace: "\u{1F605} " }),
+      textInputRule({ find: />:-\) $/, replace: "\u{1F606} " }),
+      textInputRule({ find: /-__- $/, replace: "\u{1F611} " }),
+      textInputRule({ find: /':-\( $/, replace: "\u{1F613} " }),
+      textInputRule({ find: /:'-\( $/, replace: "\u{1F622} " }),
+      textInputRule({ find: />:-\( $/, replace: "\u{1F620} " }),
+      textInputRule({ find: /O:-\) $/, replace: "\u{1F607} " }),
+      textInputRule({ find: /:'\) $/, replace: "\u{1F602} " }),
+      textInputRule({ find: /:-D $/, replace: "\u{1F603} " }),
+      textInputRule({ find: /':\) $/, replace: "\u{1F605} " }),
+      textInputRule({ find: /;-\) $/, replace: "\u{1F609} " }),
+      textInputRule({ find: /B-\) $/, replace: "\u{1F60E} " }),
+      textInputRule({ find: /:-\* $/, replace: "\u{1F618} " }),
+      textInputRule({ find: /:-\) $/, replace: "\u{1F642} " }),
+      textInputRule({ find: /-_- $/, replace: "\u{1F611} " }),
+      textInputRule({ find: /:-O $/, replace: "\u{1F62E} " }),
+      textInputRule({ find: /:-P $/, replace: "\u{1F61B} " }),
+      textInputRule({ find: /:-p $/, replace: "\u{1F61B} " }),
+      textInputRule({ find: /:-\/ $/, replace: "\u{1F615} " }),
+      textInputRule({ find: /:-\( $/, replace: "\u{1F61E} " }),
+      textInputRule({ find: /:'\( $/, replace: "\u{1F622} " }),
+      textInputRule({ find: /:D $/, replace: "\u{1F603} " }),
+      textInputRule({ find: /=D $/, replace: "\u{1F603} " }),
+      textInputRule({ find: /;\) $/, replace: "\u{1F609} " }),
+      textInputRule({ find: /B\) $/, replace: "\u{1F60E} " }),
+      textInputRule({ find: /:\) $/, replace: "\u{1F642} " }),
+      textInputRule({ find: /=\) $/, replace: "\u{1F642} " }),
+      textInputRule({ find: /:O $/, replace: "\u{1F62E} " }),
+      textInputRule({ find: /:P $/, replace: "\u{1F61B} " }),
+      textInputRule({ find: /:p $/, replace: "\u{1F61B} " }),
+      textInputRule({ find: /:\/ $/, replace: "\u{1F615} " }),
+      textInputRule({ find: /:\( $/, replace: "\u{1F61E} " }),
+      textInputRule({ find: /<3 $/, replace: "\u2764\uFE0F " }),
+      textInputRule({ find: /<\/3 $/, replace: "\u{1F494} " }),
+      textInputRule({ find: /\/shrug $/, replace: "\xAF\\_(\u30C4)_/\xAF " })
+    ];
+  }
+});
+
+// src/extensions/ColorHighlighter.ts
+import { Extension as Extension4 } from "@tiptap/core";
+import { Plugin as Plugin3 } from "@tiptap/pm/state";
+import { Decoration as Decoration2, DecorationSet as DecorationSet2 } from "@tiptap/pm/view";
+function findHexColors(doc) {
+  const hexColorRegex = /(#[0-9a-fA-F]{3,8})\b/g;
+  const decorations = [];
+  doc.descendants((node, position) => {
+    if (!node.text) return;
+    let match;
+    while ((match = hexColorRegex.exec(node.text)) !== null) {
+      const color = match[0];
+      const from = position + match.index;
+      const to = from + color.length;
+      decorations.push(
+        Decoration2.inline(from, to, {
+          class: "color-highlight px-1 py-0.5 rounded text-xs font-mono border",
+          style: `--color: ${color}; background-color: ${color}20; border-color: ${color}; color: ${color};`
+        })
+      );
+    }
+  });
+  return DecorationSet2.create(doc, decorations);
+}
+var ColorHighlighter = Extension4.create({
+  name: "colorHighlighter",
+  addProseMirrorPlugins() {
+    return [
+      new Plugin3({
+        state: {
+          init(_, { doc }) {
+            return findHexColors(doc);
+          },
+          apply(transaction, oldState) {
+            return transaction.docChanged ? findHexColors(transaction.doc) : oldState;
+          }
+        },
+        props: {
+          decorations(state) {
+            return this.getState(state);
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/extensions/FontSize.ts
+import { Extension as Extension5 } from "@tiptap/core";
+import "@tiptap/extension-text-style";
+var FontSize = Extension5.create({
+  name: "fontSize",
+  addOptions() {
+    return {
+      types: ["textStyle"]
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          fontSize: {
+            default: null,
+            parseHTML: (element) => element.style.fontSize.replace(/['"]+/g, ""),
+            renderHTML: (attributes) => {
+              if (!attributes.fontSize) {
+                return {};
+              }
+              return {
+                style: `font-size: ${attributes.fontSize}`
+              };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setFontSize: (fontSize) => ({ chain }) => chain().setMark("textStyle", { fontSize }).run(),
+      unsetFontSize: () => ({ chain }) => chain().setMark("textStyle", { fontSize: null }).removeEmptyTextStyle().run()
+    };
+  }
+});
+
+// src/extensions/rich-text-preset.ts
+import StarterKit from "@tiptap/starter-kit";
+import Color from "@tiptap/extension-color";
+import Highlight from "@tiptap/extension-highlight";
+import Link from "@tiptap/extension-link";
+import TaskList from "@tiptap/extension-task-list";
+import TaskItem from "@tiptap/extension-task-item";
+import TextAlign from "@tiptap/extension-text-align";
+import TextStyle from "@tiptap/extension-text-style";
+import Typography from "@tiptap/extension-typography";
+import Underline from "@tiptap/extension-underline";
+import Placeholder from "@tiptap/extension-placeholder";
+import CharacterCount from "@tiptap/extension-character-count";
+function createRichTextPreset(options = {}) {
+  const {
+    placeholder = "Start typing...",
+    characterLimit,
+    openLinksOnClick = false,
+    enableSmilies = true,
+    enableColorHighlighter = true,
+    headingLevels = [1, 2, 3, 4]
+  } = options;
+  const extensions = [
+    StarterKit.configure({
+      orderedList: {
+        HTMLAttributes: {
+          class: "list-decimal pl-4"
+        }
+      },
+      bulletList: {
+        HTMLAttributes: {
+          class: "list-disc pl-4"
+        }
+      },
+      heading: {
+        levels: headingLevels,
+        HTMLAttributes: {
+          class: "font-bold tracking-tight"
+        }
+      }
+    }),
+    TextStyle,
+    Color,
+    Highlight.configure({ multicolor: true }),
+    Underline,
+    Typography,
+    TextAlign.configure({
+      types: ["heading", "paragraph"]
+    }),
+    Link.configure({
+      openOnClick: openLinksOnClick,
+      autolink: true,
+      defaultProtocol: "https",
+      HTMLAttributes: {
+        target: "_blank",
+        rel: "noopener noreferrer",
+        class: "text-blue-500 underline underline-offset-2"
+      }
+    }),
+    TaskList,
+    TaskItem.configure({
+      nested: true
+    }),
+    FontSize,
+    Placeholder.configure({
+      emptyEditorClass: "is-empty",
+      placeholder: typeof placeholder === "function" ? placeholder : () => placeholder
+    })
+  ];
+  if (characterLimit) {
+    extensions.push(
+      CharacterCount.configure({
+        limit: characterLimit
+      })
+    );
+  }
+  if (enableSmilies) {
+    extensions.push(SmilieReplacer);
+  }
+  if (enableColorHighlighter) {
+    extensions.push(ColorHighlighter);
+  }
+  return extensions;
+}
+
+// src/serializers/plain-text.ts
+function escapeHtml(text) {
+  if (!text) return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function plainTextToTipTapHtml(text) {
+  if (!text) return "<p></p>";
+  if (/<p[\s>]/i.test(text)) {
+    return text;
+  }
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((line) => `<p>${escapeHtml(line)}</p>`).join("");
+}
+function htmlToPlainText(html) {
+  if (!html) return "";
+  if (typeof document !== "undefined") {
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = html;
+    tempDiv.querySelectorAll("br.ProseMirror-trailingBreak").forEach((br) => br.remove());
+    tempDiv.querySelectorAll("br").forEach((br) => br.replaceWith("\n"));
+    const paragraphs = tempDiv.querySelectorAll("p, div, li, h1, h2, h3, h4, h5, h6");
+    if (paragraphs.length > 0) {
+      const textParts = [];
+      paragraphs.forEach((p) => {
+        textParts.push(p.textContent || "");
+      });
+      return textParts.join("\n");
+    }
+    return tempDiv.textContent || "";
+  }
+  return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<\/div>/gi, "\n").replace(/<\/li>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'").trim();
+}
+function getEditorText(editor) {
+  if (!editor) return "";
+  const html = typeof editor.getHTML === "function" ? editor.getHTML() : "";
+  if (html) {
+    return htmlToPlainText(html);
+  }
+  if (typeof editor.getText === "function") {
+    try {
+      return editor.getText({ blockSeparator: "\n" });
+    } catch {
+      return editor.getText();
+    }
+  }
+  return "";
+}
+
+// src/controller.ts
+import { Editor } from "@tiptap/core";
+import { Slice, Fragment, Node as ProsemirrorNode } from "@tiptap/pm/model";
+var EditorController = class {
+  editor;
+  plainTextMode;
+  onPlainTextChange;
+  onTokensChange;
+  onSelectionChange;
+  constructor(options = {}) {
+    const {
+      element,
+      content,
+      plainTextMode = false,
+      extensions = [],
+      onPlainTextChange,
+      onTokensChange,
+      onSelectionChange,
+      ...editorOptions
+    } = options;
+    this.plainTextMode = plainTextMode;
+    this.onPlainTextChange = onPlainTextChange;
+    this.onTokensChange = onTokensChange;
+    this.onSelectionChange = onSelectionChange;
+    const initialContent = plainTextMode && typeof content === "string" ? plainTextToTipTapHtml(content) : content;
+    this.editor = new Editor({
+      element: element || void 0,
+      content: initialContent,
+      extensions,
+      ...editorOptions,
+      onUpdate: (props) => {
+        editorOptions.onUpdate?.(props);
+        this.handleUpdate();
+      },
+      onSelectionUpdate: (props) => {
+        editorOptions.onSelectionUpdate?.(props);
+        this.handleSelectionUpdate();
+      }
+    });
+    if (plainTextMode) {
+      this.enforcePlainTextClipboard();
+    }
+  }
+  enforcePlainTextClipboard() {
+    this.editor.setOptions({
+      editorProps: {
+        ...this.editor.options.editorProps,
+        clipboardTextParser: (text, context, _plain, view) => {
+          const schema = context?.doc?.type?.schema || context?.schema || view?.state?.schema || this.editor.schema;
+          if (!schema) return Slice.empty;
+          const blocks = text.replace(/\r\n?/g, "\n").split("\n");
+          const nodes = [];
+          blocks.forEach((line) => {
+            const nodeJson = { type: "paragraph" };
+            if (line.length > 0) {
+              nodeJson.content = [{ type: "text", text: line }];
+            }
+            try {
+              const node = ProsemirrorNode.fromJSON(schema, nodeJson);
+              nodes.push(node);
+            } catch {
+            }
+          });
+          return Slice.maxOpen(Fragment.fromArray(nodes));
+        }
+      }
+    });
+  }
+  handleUpdate() {
+    if (this.plainTextMode || this.onPlainTextChange || this.onTokensChange) {
+      const text = this.getPlainText();
+      this.onPlainTextChange?.(text);
+      if (this.onTokensChange) {
+        const tokens = tokenizePrompt(text);
+        this.onTokensChange(tokens);
+      }
+    }
+  }
+  handleSelectionUpdate() {
+    if (this.onSelectionChange) {
+      const { from, to } = this.editor.state.selection;
+      this.onSelectionChange({ from, to });
+    }
+  }
+  getPlainText() {
+    return getEditorText(this.editor);
+  }
+  setPlainText(text, emitUpdate = true) {
+    const html = plainTextToTipTapHtml(text);
+    this.editor.commands.setContent(html, emitUpdate);
+  }
+  insertText(text) {
+    this.editor.commands.insertContent(text);
+  }
+  insertTextAt(pos, text) {
+    this.editor.chain().focus().insertContentAt(pos, text).run();
+  }
+  replaceRange(from, to, text) {
+    this.editor.chain().focus().deleteRange({ from, to }).insertContentAt(from, text).run();
+  }
+  destroy() {
+    this.editor.destroy();
+  }
+};
+function createEditor(options = {}) {
+  return new EditorController(options);
+}
+export {
+  ColorHighlighter,
+  EditorController,
+  FontSize,
+  GradientText,
+  INSTRUCTION_REGEX,
+  LoadingNode,
+  SlashCommands,
+  SmilieReplacer,
+  TEMPLATE_REGEX,
+  TemplateSuggestions,
+  VARIABLE_REGEX,
+  createEditor,
+  createRichTextPreset,
+  escapeHtml,
+  extractInstructionNames,
+  extractTemplateNames,
+  extractVariableNames,
+  findHexColors,
+  getEditorText,
+  getLatestVersion,
+  htmlToPlainText,
+  instructionRegex,
+  mapRawOffsetToResolved,
+  mapResolvedOffsetToRaw,
+  plainTextToTipTapHtml,
+  resolveTemplates,
+  resolveTemplatesWithMapping,
+  resolveVariables,
+  templateRegex,
+  tokenizePrompt,
+  variableRegex
+};
+//# sourceMappingURL=index.js.map