@aeriz/wysiwyg 1.0.4 → 2.0.0

package/dist/highlight.js

@@ -0,0 +1,895 @@
+const h = {
+  lineComment: "//",
+  blockComment: { start: "/*", end: "*/" },
+  stringDelims: ['"', "'"]
+}, g = /* @__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"
+]), k = /* @__PURE__ */ new Set([
+  ...g,
+  "any",
+  "as",
+  "asserts",
+  "boolean",
+  "declare",
+  "infer",
+  "is",
+  "keyof",
+  "module",
+  "namespace",
+  "never",
+  "number",
+  "object",
+  "override",
+  "readonly",
+  "require",
+  "satisfies",
+  "string",
+  "symbol",
+  "type",
+  "unique",
+  "unknown"
+]), S = /* @__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"
+]), x = /* @__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"
+]), b = /* @__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"
+]), v = /* @__PURE__ */ new Set([
+  ...b,
+  "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"
+]), _ = /* @__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"
+]), $ = /* @__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"
+]), O = /* @__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"
+]), C = /* @__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"
+]), A = /* @__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"
+]), D = /* @__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"
+]), W = /* @__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"
+]), E = /* @__PURE__ */ new Set(["true", "false", "null"]), y = [
+  {
+    id: "plaintext",
+    label: "Plain Text",
+    keywords: /* @__PURE__ */ new Set()
+  },
+  {
+    id: "javascript",
+    label: "JavaScript",
+    keywords: g,
+    ...h,
+    stringDelims: ['"', "'", "`"]
+  },
+  {
+    id: "typescript",
+    label: "TypeScript",
+    keywords: k,
+    ...h,
+    stringDelims: ['"', "'", "`"]
+  },
+  {
+    id: "python",
+    label: "Python",
+    keywords: S,
+    builtins: x,
+    lineComment: "#",
+    stringDelims: ['"', "'"]
+  },
+  {
+    id: "json",
+    label: "JSON",
+    keywords: E,
+    stringDelims: ['"']
+  },
+  {
+    id: "html",
+    label: "HTML",
+    keywords: /* @__PURE__ */ new Set(),
+    custom: (e) => T(e)
+  },
+  {
+    id: "css",
+    label: "CSS",
+    keywords: /* @__PURE__ */ new Set(),
+    custom: (e) => M(e)
+  },
+  {
+    id: "bash",
+    label: "Bash",
+    keywords: D,
+    lineComment: "#",
+    stringDelims: ['"', "'"]
+  },
+  {
+    id: "sql",
+    label: "SQL",
+    keywords: W,
+    caseInsensitiveKeywords: !0,
+    lineComment: "--",
+    blockComment: { start: "/*", end: "*/" },
+    stringDelims: ['"', "'"]
+  },
+  {
+    id: "markdown",
+    label: "Markdown",
+    keywords: /* @__PURE__ */ new Set(),
+    custom: (e) => N(e)
+  },
+  { id: "c", label: "C", keywords: b, ...h },
+  { id: "cpp", label: "C++", keywords: v, ...h },
+  { id: "csharp", label: "C#", keywords: _, ...h },
+  { id: "java", label: "Java", keywords: $, ...h },
+  { id: "kotlin", label: "Kotlin", keywords: O, ...h },
+  { id: "go", label: "Go", keywords: C, ...h },
+  { id: "rust", label: "Rust", keywords: A, ...h }
+], R = (() => {
+  const e = /* @__PURE__ */ new Map();
+  for (const t of y) e.set(t.id, t);
+  return e;
+})(), K = "plaintext";
+function Y(e, t) {
+  if (!t || t === K) return a(e);
+  const n = R.get(t);
+  return n ? n.custom ? n.custom(e) : z(e, n) : a(e);
+}
+function z(e, t) {
+  var c, i;
+  const n = !!t.caseInsensitiveKeywords;
+  let o = "", s = 0;
+  const l = e.length;
+  for (; s < l; ) {
+    if (t.lineComment && e.startsWith(t.lineComment, s)) {
+      const r = e.indexOf(`
+`, s), p = r === -1 ? l : r;
+      o += `<span class="hl-comment">${a(e.slice(s, p))}</span>`, s = p;
+      continue;
+    }
+    if (t.blockComment && e.startsWith(t.blockComment.start, s)) {
+      const r = e.indexOf(t.blockComment.end, s + t.blockComment.start.length), p = r === -1 ? l : r + t.blockComment.end.length;
+      o += `<span class="hl-comment">${a(e.slice(s, p))}</span>`, s = p;
+      continue;
+    }
+    const u = (c = t.stringDelims) == null ? void 0 : c.find((r) => e.startsWith(r, s));
+    if (u) {
+      let r = s + u.length;
+      for (; r < l; ) {
+        const p = e[r] ?? "";
+        if (p === "\\") {
+          r += 2;
+          continue;
+        }
+        if (e.startsWith(u, r)) {
+          r += u.length;
+          break;
+        }
+        if (p === `
+` && u !== "`") break;
+        r++;
+      }
+      o += `<span class="hl-string">${a(e.slice(s, r))}</span>`, s = r;
+      continue;
+    }
+    const f = e[s] ?? "";
+    if (/[0-9]/.test(f)) {
+      const r = L.exec(e.slice(s));
+      if (r) {
+        o += `<span class="hl-number">${a(r[0])}</span>`, s += r[0].length;
+        continue;
+      }
+    }
+    if (/[a-zA-Z_$]/.test(f)) {
+      let r = s + 1;
+      for (; r < l && /[a-zA-Z0-9_$]/.test(e[r] ?? ""); ) r++;
+      const p = e.slice(s, r), w = n ? p.toLowerCase() : p;
+      if (t.keywords.has(w))
+        o += `<span class="hl-keyword">${a(p)}</span>`;
+      else if ((i = t.builtins) != null && i.has(w))
+        o += `<span class="hl-builtin">${a(p)}</span>`;
+      else {
+        let d = r;
+        for (; d < l && (e[d] === " " || e[d] === "	"); ) d++;
+        e[d] === "(" ? o += `<span class="hl-fn">${a(p)}</span>` : o += a(p);
+      }
+      s = r;
+      continue;
+    }
+    o += a(f), s++;
+  }
+  return o;
+}
+const L = /^(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 T(e) {
+  let t = "", n = 0;
+  const o = e.length;
+  for (; n < o; ) {
+    if (e.startsWith("<!--", n)) {
+      const s = e.indexOf("-->", n + 4), l = s === -1 ? o : s + 3;
+      t += `<span class="hl-comment">${a(e.slice(n, l))}</span>`, n = l;
+      continue;
+    }
+    if (e[n] === "<") {
+      const s = e.indexOf(">", n);
+      if (s === -1) {
+        t += a(e.slice(n));
+        break;
+      }
+      const l = e.slice(n, s + 1);
+      t += j(l), n = s + 1;
+      continue;
+    }
+    t += a(e[n] ?? ""), n++;
+  }
+  return t;
+}
+function j(e) {
+  const t = e.slice(1, -1);
+  let n = '<span class="hl-punct">&lt;</span>';
+  const o = /^\/?[a-zA-Z][a-zA-Z0-9-]*/.exec(t);
+  if (o) {
+    n += `<span class="hl-tag">${a(o[0])}</span>`;
+    let s = t.slice(o[0].length);
+    const l = /\s+([a-zA-Z_:][a-zA-Z0-9_:.-]*)(\s*=\s*("([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+    let c = 0, i;
+    for (; i = l.exec(s); ) {
+      n += a(s.slice(c, i.index)), n += a(s.slice(i.index, i.index + i[0].indexOf(i[1] ?? ""))), n += `<span class="hl-attr">${a(i[1] ?? "")}</span>`;
+      const u = s.slice(i.index + (i[0].indexOf(i[1] ?? "") + (i[1] ?? "").length), i.index + i[0].length);
+      if (u.includes("=")) {
+        const f = u.indexOf("=");
+        n += a(u.slice(0, f + 1));
+        const r = u.slice(f + 1);
+        n += `<span class="hl-string">${a(r)}</span>`;
+      }
+      c = i.index + i[0].length;
+    }
+    n += a(s.slice(c));
+  } else
+    n += a(t);
+  return n += '<span class="hl-punct">&gt;</span>', n;
+}
+function M(e) {
+  let t = "", n = 0;
+  const o = e.length;
+  let s = !1;
+  for (; n < o; ) {
+    if (e.startsWith("/*", n)) {
+      const c = e.indexOf("*/", n + 2), i = c === -1 ? o : c + 2;
+      t += `<span class="hl-comment">${a(e.slice(n, i))}</span>`, n = i;
+      continue;
+    }
+    const l = e[n] ?? "";
+    if (l === "{") {
+      s = !0, t += a(l), n++;
+      continue;
+    }
+    if (l === "}") {
+      s = !1, t += a(l), n++;
+      continue;
+    }
+    if (l === '"' || l === "'") {
+      const c = l;
+      let i = n + 1;
+      for (; i < o && e[i] !== c; )
+        e[i] === "\\" ? i += 2 : i++;
+      i = Math.min(i + 1, o), t += `<span class="hl-string">${a(e.slice(n, i))}</span>`, n = i;
+      continue;
+    }
+    if (/[a-zA-Z_-]/.test(l) || l === "@" || l === "#" || l === "." || l === ":") {
+      let c = n + 1;
+      for (; c < o && /[a-zA-Z0-9_-]/.test(e[c] ?? ""); ) c++;
+      const i = e.slice(n, c);
+      if (l === "@")
+        t += `<span class="hl-keyword">${a(i)}</span>`;
+      else if (s && /^[a-zA-Z-]+$/.test(i)) {
+        let u = c;
+        for (; u < o && (e[u] === " " || e[u] === "	"); ) u++;
+        e[u] === ":" ? t += `<span class="hl-prop">${a(i)}</span>` : t += a(i);
+      } else
+        t += `<span class="hl-tag">${a(i)}</span>`;
+      n = c;
+      continue;
+    }
+    if (/[0-9]/.test(l)) {
+      const c = /^[0-9.]+(px|em|rem|%|vh|vw|s|ms|deg|fr)?/.exec(e.slice(n));
+      if (c) {
+        t += `<span class="hl-number">${a(c[0])}</span>`, n += c[0].length;
+        continue;
+      }
+    }
+    t += a(l), n++;
+  }
+  return t;
+}
+function N(e) {
+  return e.split(`
+`).map(Z).join(`
+`);
+}
+function Z(e) {
+  const t = /^(#{1,6})\s+(.*)$/.exec(e);
+  if (t)
+    return `<span class="hl-keyword">${a(t[1] ?? "")}</span> <span class="hl-tag">${m(t[2] ?? "")}</span>`;
+  if (e.startsWith(">"))
+    return `<span class="hl-comment">${a(e)}</span>`;
+  if (e.startsWith("```"))
+    return `<span class="hl-keyword">${a(e)}</span>`;
+  const n = /^(\s*)([-*+]|\d+\.)\s+(.*)$/.exec(e);
+  return n ? `${n[1] ?? ""}<span class="hl-keyword">${a(n[2] ?? "")}</span> ${m(n[3] ?? "")}` : m(e);
+}
+function m(e) {
+  let t = a(e);
+  return t = t.replace(/\*\*([^*]+)\*\*/g, '<span class="hl-keyword">**$1**</span>'), t = t.replace(new RegExp("(?<!\\*)\\*([^*]+)\\*(?!\\*)", "g"), '<span class="hl-string">*$1*</span>'), t = t.replace(/`([^`]+)`/g, '<span class="hl-builtin">`$1`</span>'), t = t.replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    '<span class="hl-tag">[$1]</span><span class="hl-string">($2)</span>'
+  ), t;
+}
+function a(e) {
+  return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+const B = {
+  languages: y.map(({ id: e, label: t }) => ({ id: e, label: t })),
+  highlight: Y
+};
+export {
+  B as highlighter
+};