@aeriz/wysiwyg 1.0.4 → 2.0.0

package/dist/aeriz-wysiwyg-highlight.js

@@ -0,0 +1,964 @@
+var AerizWysiwygHighlight = function(exports) {
+  "use strict";
+  const C_FAMILY_BASE = {
+    lineComment: "//",
+    blockComment: { start: "/*", end: "*/" },
+    stringDelims: ['"', "'"]
+  };
+  const JS_KEYWORDS = /* @__PURE__ */ new Set([
+    "abstract",
+    "arguments",
+    "async",
+    "await",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "let",
+    "new",
+    "null",
+    "of",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "set",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "false",
+    "try",
+    "typeof",
+    "undefined",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+  ]);
+  const TS_KEYWORDS = /* @__PURE__ */ new Set([
+    ...JS_KEYWORDS,
+    "any",
+    "as",
+    "asserts",
+    "boolean",
+    "declare",
+    "infer",
+    "is",
+    "keyof",
+    "module",
+    "namespace",
+    "never",
+    "number",
+    "object",
+    "override",
+    "readonly",
+    "require",
+    "satisfies",
+    "string",
+    "symbol",
+    "type",
+    "unique",
+    "unknown"
+  ]);
+  const PY_KEYWORDS = /* @__PURE__ */ new Set([
+    "False",
+    "None",
+    "True",
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield"
+  ]);
+  const PY_BUILTINS = /* @__PURE__ */ new Set([
+    "abs",
+    "all",
+    "any",
+    "bool",
+    "dict",
+    "enumerate",
+    "filter",
+    "float",
+    "int",
+    "isinstance",
+    "len",
+    "list",
+    "map",
+    "max",
+    "min",
+    "open",
+    "print",
+    "range",
+    "set",
+    "sorted",
+    "str",
+    "sum",
+    "tuple",
+    "type",
+    "zip",
+    "self",
+    "cls"
+  ]);
+  const C_KEYWORDS = /* @__PURE__ */ new Set([
+    "auto",
+    "break",
+    "case",
+    "char",
+    "const",
+    "continue",
+    "default",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "extern",
+    "float",
+    "for",
+    "goto",
+    "if",
+    "int",
+    "long",
+    "register",
+    "return",
+    "short",
+    "signed",
+    "sizeof",
+    "static",
+    "struct",
+    "switch",
+    "typedef",
+    "union",
+    "unsigned",
+    "void",
+    "volatile",
+    "while",
+    "inline",
+    "restrict",
+    "_Bool",
+    "NULL"
+  ]);
+  const CPP_KEYWORDS = /* @__PURE__ */ new Set([
+    ...C_KEYWORDS,
+    "class",
+    "new",
+    "delete",
+    "try",
+    "catch",
+    "throw",
+    "template",
+    "typename",
+    "namespace",
+    "using",
+    "public",
+    "private",
+    "protected",
+    "virtual",
+    "override",
+    "this",
+    "nullptr",
+    "true",
+    "false",
+    "bool",
+    "explicit",
+    "friend",
+    "mutable",
+    "operator",
+    "reinterpret_cast",
+    "static_cast",
+    "dynamic_cast",
+    "const_cast",
+    "constexpr",
+    "decltype",
+    "noexcept",
+    "final",
+    "auto"
+  ]);
+  const CSHARP_KEYWORDS = /* @__PURE__ */ new Set([
+    "abstract",
+    "async",
+    "await",
+    "base",
+    "bool",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "checked",
+    "class",
+    "const",
+    "continue",
+    "decimal",
+    "default",
+    "delegate",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "event",
+    "explicit",
+    "extern",
+    "false",
+    "finally",
+    "fixed",
+    "float",
+    "for",
+    "foreach",
+    "goto",
+    "if",
+    "implicit",
+    "in",
+    "int",
+    "interface",
+    "internal",
+    "is",
+    "lock",
+    "long",
+    "namespace",
+    "new",
+    "null",
+    "object",
+    "operator",
+    "out",
+    "override",
+    "params",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "ref",
+    "return",
+    "sbyte",
+    "sealed",
+    "short",
+    "sizeof",
+    "stackalloc",
+    "static",
+    "string",
+    "struct",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "uint",
+    "ulong",
+    "unchecked",
+    "unsafe",
+    "ushort",
+    "using",
+    "var",
+    "virtual",
+    "void",
+    "volatile",
+    "while",
+    "yield",
+    "record",
+    "init",
+    "nameof",
+    "when"
+  ]);
+  const JAVA_KEYWORDS = /* @__PURE__ */ new Set([
+    "abstract",
+    "assert",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "default",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "extends",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "instanceof",
+    "int",
+    "interface",
+    "long",
+    "native",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "short",
+    "static",
+    "strictfp",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "transient",
+    "true",
+    "false",
+    "try",
+    "void",
+    "volatile",
+    "while",
+    "var",
+    "yield",
+    "record",
+    "sealed",
+    "permits",
+    "non-sealed"
+  ]);
+  const KOTLIN_KEYWORDS = /* @__PURE__ */ new Set([
+    "abstract",
+    "actual",
+    "annotation",
+    "as",
+    "break",
+    "by",
+    "catch",
+    "class",
+    "companion",
+    "const",
+    "constructor",
+    "continue",
+    "crossinline",
+    "data",
+    "do",
+    "dynamic",
+    "else",
+    "enum",
+    "expect",
+    "external",
+    "false",
+    "final",
+    "finally",
+    "for",
+    "fun",
+    "get",
+    "if",
+    "import",
+    "in",
+    "init",
+    "inline",
+    "inner",
+    "interface",
+    "internal",
+    "is",
+    "it",
+    "lateinit",
+    "null",
+    "object",
+    "open",
+    "operator",
+    "out",
+    "override",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "reified",
+    "return",
+    "sealed",
+    "set",
+    "super",
+    "suspend",
+    "tailrec",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typealias",
+    "typeof",
+    "val",
+    "var",
+    "vararg",
+    "when",
+    "where",
+    "while"
+  ]);
+  const GO_KEYWORDS = /* @__PURE__ */ new Set([
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "else",
+    "fallthrough",
+    "for",
+    "func",
+    "go",
+    "goto",
+    "if",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "return",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var",
+    "true",
+    "false",
+    "nil",
+    "iota"
+  ]);
+  const RUST_KEYWORDS = /* @__PURE__ */ new Set([
+    "as",
+    "async",
+    "await",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "type",
+    "unsafe",
+    "use",
+    "where",
+    "while",
+    "box",
+    "do",
+    "final",
+    "macro",
+    "override",
+    "priv",
+    "typeof",
+    "unsized",
+    "virtual",
+    "yield"
+  ]);
+  const BASH_KEYWORDS = /* @__PURE__ */ new Set([
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "case",
+    "esac",
+    "for",
+    "while",
+    "until",
+    "do",
+    "done",
+    "function",
+    "return",
+    "select",
+    "break",
+    "continue",
+    "in",
+    "echo",
+    "export",
+    "local",
+    "readonly",
+    "declare",
+    "typeset",
+    "unset",
+    "eval",
+    "exec",
+    "source",
+    "true",
+    "false"
+  ]);
+  const SQL_KEYWORDS = /* @__PURE__ */ new Set([
+    "select",
+    "from",
+    "where",
+    "insert",
+    "update",
+    "delete",
+    "into",
+    "values",
+    "set",
+    "create",
+    "table",
+    "drop",
+    "alter",
+    "index",
+    "view",
+    "join",
+    "inner",
+    "left",
+    "right",
+    "outer",
+    "full",
+    "cross",
+    "on",
+    "group",
+    "by",
+    "order",
+    "having",
+    "limit",
+    "offset",
+    "union",
+    "all",
+    "distinct",
+    "as",
+    "and",
+    "or",
+    "not",
+    "null",
+    "true",
+    "false",
+    "is",
+    "in",
+    "between",
+    "like",
+    "exists",
+    "primary",
+    "key",
+    "foreign",
+    "references",
+    "unique",
+    "default",
+    "check",
+    "constraint",
+    "database",
+    "schema",
+    "with",
+    "case",
+    "when",
+    "then",
+    "else",
+    "end",
+    "cast",
+    "count",
+    "sum",
+    "avg",
+    "min",
+    "max",
+    "asc",
+    "desc"
+  ]);
+  const JSON_KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "null"]);
+  const LANGUAGES = [
+    {
+      id: "plaintext",
+      label: "Plain Text",
+      keywords: /* @__PURE__ */ new Set()
+    },
+    {
+      id: "javascript",
+      label: "JavaScript",
+      keywords: JS_KEYWORDS,
+      ...C_FAMILY_BASE,
+      stringDelims: ['"', "'", "`"]
+    },
+    {
+      id: "typescript",
+      label: "TypeScript",
+      keywords: TS_KEYWORDS,
+      ...C_FAMILY_BASE,
+      stringDelims: ['"', "'", "`"]
+    },
+    {
+      id: "python",
+      label: "Python",
+      keywords: PY_KEYWORDS,
+      builtins: PY_BUILTINS,
+      lineComment: "#",
+      stringDelims: ['"', "'"]
+    },
+    {
+      id: "json",
+      label: "JSON",
+      keywords: JSON_KEYWORDS,
+      stringDelims: ['"']
+    },
+    {
+      id: "html",
+      label: "HTML",
+      keywords: /* @__PURE__ */ new Set(),
+      custom: (code) => highlightHtml(code)
+    },
+    {
+      id: "css",
+      label: "CSS",
+      keywords: /* @__PURE__ */ new Set(),
+      custom: (code) => highlightCss(code)
+    },
+    {
+      id: "bash",
+      label: "Bash",
+      keywords: BASH_KEYWORDS,
+      lineComment: "#",
+      stringDelims: ['"', "'"]
+    },
+    {
+      id: "sql",
+      label: "SQL",
+      keywords: SQL_KEYWORDS,
+      caseInsensitiveKeywords: true,
+      lineComment: "--",
+      blockComment: { start: "/*", end: "*/" },
+      stringDelims: ['"', "'"]
+    },
+    {
+      id: "markdown",
+      label: "Markdown",
+      keywords: /* @__PURE__ */ new Set(),
+      custom: (code) => highlightMarkdown(code)
+    },
+    { id: "c", label: "C", keywords: C_KEYWORDS, ...C_FAMILY_BASE },
+    { id: "cpp", label: "C++", keywords: CPP_KEYWORDS, ...C_FAMILY_BASE },
+    { id: "csharp", label: "C#", keywords: CSHARP_KEYWORDS, ...C_FAMILY_BASE },
+    { id: "java", label: "Java", keywords: JAVA_KEYWORDS, ...C_FAMILY_BASE },
+    { id: "kotlin", label: "Kotlin", keywords: KOTLIN_KEYWORDS, ...C_FAMILY_BASE },
+    { id: "go", label: "Go", keywords: GO_KEYWORDS, ...C_FAMILY_BASE },
+    { id: "rust", label: "Rust", keywords: RUST_KEYWORDS, ...C_FAMILY_BASE }
+  ];
+  const LANG_BY_ID = (() => {
+    const m = /* @__PURE__ */ new Map();
+    for (const l of LANGUAGES) m.set(l.id, l);
+    return m;
+  })();
+  const PLAIN_TEXT_ID = "plaintext";
+  function highlightCode(code, langId) {
+    if (!langId || langId === PLAIN_TEXT_ID) return escapeHtml(code);
+    const lang = LANG_BY_ID.get(langId);
+    if (!lang) return escapeHtml(code);
+    if (lang.custom) return lang.custom(code);
+    return tokenize(code, lang);
+  }
+  function tokenize(code, lang) {
+    var _a, _b;
+    const ci = !!lang.caseInsensitiveKeywords;
+    let out = "";
+    let i = 0;
+    const n = code.length;
+    while (i < n) {
+      if (lang.lineComment && code.startsWith(lang.lineComment, i)) {
+        const nl = code.indexOf("\n", i);
+        const stop = nl === -1 ? n : nl;
+        out += `<span class="hl-comment">${escapeHtml(code.slice(i, stop))}</span>`;
+        i = stop;
+        continue;
+      }
+      if (lang.blockComment && code.startsWith(lang.blockComment.start, i)) {
+        const closeAt = code.indexOf(lang.blockComment.end, i + lang.blockComment.start.length);
+        const stop = closeAt === -1 ? n : closeAt + lang.blockComment.end.length;
+        out += `<span class="hl-comment">${escapeHtml(code.slice(i, stop))}</span>`;
+        i = stop;
+        continue;
+      }
+      const sd = (_a = lang.stringDelims) == null ? void 0 : _a.find((d) => code.startsWith(d, i));
+      if (sd) {
+        let j = i + sd.length;
+        while (j < n) {
+          const c = code[j] ?? "";
+          if (c === "\\") {
+            j += 2;
+            continue;
+          }
+          if (code.startsWith(sd, j)) {
+            j += sd.length;
+            break;
+          }
+          if (c === "\n" && sd !== "`") break;
+          j++;
+        }
+        out += `<span class="hl-string">${escapeHtml(code.slice(i, j))}</span>`;
+        i = j;
+        continue;
+      }
+      const ch = code[i] ?? "";
+      if (/[0-9]/.test(ch)) {
+        const m = NUMBER_RE.exec(code.slice(i));
+        if (m) {
+          out += `<span class="hl-number">${escapeHtml(m[0])}</span>`;
+          i += m[0].length;
+          continue;
+        }
+      }
+      if (/[a-zA-Z_$]/.test(ch)) {
+        let j = i + 1;
+        while (j < n && /[a-zA-Z0-9_$]/.test(code[j] ?? "")) j++;
+        const word = code.slice(i, j);
+        const lookup = ci ? word.toLowerCase() : word;
+        if (lang.keywords.has(lookup)) {
+          out += `<span class="hl-keyword">${escapeHtml(word)}</span>`;
+        } else if ((_b = lang.builtins) == null ? void 0 : _b.has(lookup)) {
+          out += `<span class="hl-builtin">${escapeHtml(word)}</span>`;
+        } else {
+          let k = j;
+          while (k < n && (code[k] === " " || code[k] === "	")) k++;
+          if (code[k] === "(") {
+            out += `<span class="hl-fn">${escapeHtml(word)}</span>`;
+          } else {
+            out += escapeHtml(word);
+          }
+        }
+        i = j;
+        continue;
+      }
+      out += escapeHtml(ch);
+      i++;
+    }
+    return out;
+  }
+  const NUMBER_RE = /^(0[xX][0-9a-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+|[0-9][0-9_]*(?:\.[0-9_]+)?(?:[eE][-+]?[0-9_]+)?)[a-zA-Z]*/;
+  function highlightHtml(code) {
+    let out = "";
+    let i = 0;
+    const n = code.length;
+    while (i < n) {
+      if (code.startsWith("<!--", i)) {
+        const end = code.indexOf("-->", i + 4);
+        const stop = end === -1 ? n : end + 3;
+        out += `<span class="hl-comment">${escapeHtml(code.slice(i, stop))}</span>`;
+        i = stop;
+        continue;
+      }
+      if (code[i] === "<") {
+        const end = code.indexOf(">", i);
+        if (end === -1) {
+          out += escapeHtml(code.slice(i));
+          break;
+        }
+        const tag = code.slice(i, end + 1);
+        out += highlightHtmlTag(tag);
+        i = end + 1;
+        continue;
+      }
+      out += escapeHtml(code[i] ?? "");
+      i++;
+    }
+    return out;
+  }
+  function highlightHtmlTag(tag) {
+    const inner = tag.slice(1, -1);
+    let result = '<span class="hl-punct">&lt;</span>';
+    const nameMatch = /^\/?[a-zA-Z][a-zA-Z0-9-]*/.exec(inner);
+    if (nameMatch) {
+      result += `<span class="hl-tag">${escapeHtml(nameMatch[0])}</span>`;
+      let rest = inner.slice(nameMatch[0].length);
+      const ATTR_RE = /\s+([a-zA-Z_:][a-zA-Z0-9_:.-]*)(\s*=\s*("([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+      let last = 0;
+      let m;
+      while (m = ATTR_RE.exec(rest)) {
+        result += escapeHtml(rest.slice(last, m.index));
+        result += escapeHtml(rest.slice(m.index, m.index + m[0].indexOf(m[1] ?? "")));
+        result += `<span class="hl-attr">${escapeHtml(m[1] ?? "")}</span>`;
+        const valuePart = rest.slice(m.index + (m[0].indexOf(m[1] ?? "") + (m[1] ?? "").length), m.index + m[0].length);
+        if (valuePart.includes("=")) {
+          const eqIdx = valuePart.indexOf("=");
+          result += escapeHtml(valuePart.slice(0, eqIdx + 1));
+          const valueStr = valuePart.slice(eqIdx + 1);
+          result += `<span class="hl-string">${escapeHtml(valueStr)}</span>`;
+        }
+        last = m.index + m[0].length;
+      }
+      result += escapeHtml(rest.slice(last));
+    } else {
+      result += escapeHtml(inner);
+    }
+    result += '<span class="hl-punct">&gt;</span>';
+    return result;
+  }
+  function highlightCss(code) {
+    let out = "";
+    let i = 0;
+    const n = code.length;
+    let inBlock = false;
+    while (i < n) {
+      if (code.startsWith("/*", i)) {
+        const end = code.indexOf("*/", i + 2);
+        const stop = end === -1 ? n : end + 2;
+        out += `<span class="hl-comment">${escapeHtml(code.slice(i, stop))}</span>`;
+        i = stop;
+        continue;
+      }
+      const ch = code[i] ?? "";
+      if (ch === "{") {
+        inBlock = true;
+        out += escapeHtml(ch);
+        i++;
+        continue;
+      }
+      if (ch === "}") {
+        inBlock = false;
+        out += escapeHtml(ch);
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const sd = ch;
+        let j = i + 1;
+        while (j < n && code[j] !== sd) {
+          if (code[j] === "\\") j += 2;
+          else j++;
+        }
+        j = Math.min(j + 1, n);
+        out += `<span class="hl-string">${escapeHtml(code.slice(i, j))}</span>`;
+        i = j;
+        continue;
+      }
+      if (/[a-zA-Z_-]/.test(ch) || ch === "@" || ch === "#" || ch === "." || ch === ":") {
+        let j = i + 1;
+        while (j < n && /[a-zA-Z0-9_-]/.test(code[j] ?? "")) j++;
+        const word = code.slice(i, j);
+        if (ch === "@") {
+          out += `<span class="hl-keyword">${escapeHtml(word)}</span>`;
+        } else if (inBlock && /^[a-zA-Z-]+$/.test(word)) {
+          let k = j;
+          while (k < n && (code[k] === " " || code[k] === "	")) k++;
+          if (code[k] === ":") {
+            out += `<span class="hl-prop">${escapeHtml(word)}</span>`;
+          } else {
+            out += escapeHtml(word);
+          }
+        } else {
+          out += `<span class="hl-tag">${escapeHtml(word)}</span>`;
+        }
+        i = j;
+        continue;
+      }
+      if (/[0-9]/.test(ch)) {
+        const m = /^[0-9.]+(px|em|rem|%|vh|vw|s|ms|deg|fr)?/.exec(code.slice(i));
+        if (m) {
+          out += `<span class="hl-number">${escapeHtml(m[0])}</span>`;
+          i += m[0].length;
+          continue;
+        }
+      }
+      out += escapeHtml(ch);
+      i++;
+    }
+    return out;
+  }
+  function highlightMarkdown(code) {
+    return code.split("\n").map(highlightMdLine).join("\n");
+  }
+  function highlightMdLine(line) {
+    const h = /^(#{1,6})\s+(.*)$/.exec(line);
+    if (h) {
+      return `<span class="hl-keyword">${escapeHtml(h[1] ?? "")}</span> <span class="hl-tag">${highlightMdInline(h[2] ?? "")}</span>`;
+    }
+    if (line.startsWith(">")) {
+      return `<span class="hl-comment">${escapeHtml(line)}</span>`;
+    }
+    if (line.startsWith("```")) {
+      return `<span class="hl-keyword">${escapeHtml(line)}</span>`;
+    }
+    const li = /^(\s*)([-*+]|\d+\.)\s+(.*)$/.exec(line);
+    if (li) {
+      return `${li[1] ?? ""}<span class="hl-keyword">${escapeHtml(li[2] ?? "")}</span> ${highlightMdInline(li[3] ?? "")}`;
+    }
+    return highlightMdInline(line);
+  }
+  function highlightMdInline(s) {
+    let out = escapeHtml(s);
+    out = out.replace(/\*\*([^*]+)\*\*/g, '<span class="hl-keyword">**$1**</span>');
+    out = out.replace(new RegExp("(?<!\\*)\\*([^*]+)\\*(?!\\*)", "g"), '<span class="hl-string">*$1*</span>');
+    out = out.replace(/`([^`]+)`/g, '<span class="hl-builtin">`$1`</span>');
+    out = out.replace(
+      /\[([^\]]+)\]\(([^)]+)\)/g,
+      '<span class="hl-tag">[$1]</span><span class="hl-string">($2)</span>'
+    );
+    return out;
+  }
+  function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  const highlighter = {
+    languages: LANGUAGES.map(({ id, label }) => ({ id, label })),
+    highlight: highlightCode
+  };
+  exports.highlighter = highlighter;
+  Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+  return exports;
+}({});