@aiao/code-editor-vue 0.0.7 → 0.0.8

package/dist/erlang-CFOYdy9e-DULXsFZl.js

@@ -0,0 +1,487 @@
+var x = [
+  "-type",
+  "-spec",
+  "-export_type",
+  "-opaque"
+], S = [
+  "after",
+  "begin",
+  "catch",
+  "case",
+  "cond",
+  "end",
+  "fun",
+  "if",
+  "let",
+  "of",
+  "query",
+  "receive",
+  "try",
+  "when"
+], z = /[\->,;]/, W = [
+  "->",
+  ";",
+  ","
+], U = [
+  "and",
+  "andalso",
+  "band",
+  "bnot",
+  "bor",
+  "bsl",
+  "bsr",
+  "bxor",
+  "div",
+  "not",
+  "or",
+  "orelse",
+  "rem",
+  "xor"
+], A = /[\+\-\*\/<>=\|:!]/, E = [
+  "=",
+  "+",
+  "-",
+  "*",
+  "/",
+  ">",
+  ">=",
+  "<",
+  "=<",
+  "=:=",
+  "==",
+  "=/=",
+  "/=",
+  "||",
+  "<-",
+  "!"
+], Z = /[<\(\[\{]/, d = [
+  "<<",
+  "(",
+  "[",
+  "{"
+], q = /[>\)\]\}]/, y = [
+  "}",
+  "]",
+  ")",
+  ">>"
+], T = [
+  "is_atom",
+  "is_binary",
+  "is_bitstring",
+  "is_boolean",
+  "is_float",
+  "is_function",
+  "is_integer",
+  "is_list",
+  "is_number",
+  "is_pid",
+  "is_port",
+  "is_record",
+  "is_reference",
+  "is_tuple",
+  "atom",
+  "binary",
+  "bitstring",
+  "boolean",
+  "function",
+  "integer",
+  "list",
+  "number",
+  "pid",
+  "port",
+  "record",
+  "reference",
+  "tuple"
+], D = [
+  "abs",
+  "adler32",
+  "adler32_combine",
+  "alive",
+  "apply",
+  "atom_to_binary",
+  "atom_to_list",
+  "binary_to_atom",
+  "binary_to_existing_atom",
+  "binary_to_list",
+  "binary_to_term",
+  "bit_size",
+  "bitstring_to_list",
+  "byte_size",
+  "check_process_code",
+  "contact_binary",
+  "crc32",
+  "crc32_combine",
+  "date",
+  "decode_packet",
+  "delete_module",
+  "disconnect_node",
+  "element",
+  "erase",
+  "exit",
+  "float",
+  "float_to_list",
+  "garbage_collect",
+  "get",
+  "get_keys",
+  "group_leader",
+  "halt",
+  "hd",
+  "integer_to_list",
+  "internal_bif",
+  "iolist_size",
+  "iolist_to_binary",
+  "is_alive",
+  "is_atom",
+  "is_binary",
+  "is_bitstring",
+  "is_boolean",
+  "is_float",
+  "is_function",
+  "is_integer",
+  "is_list",
+  "is_number",
+  "is_pid",
+  "is_port",
+  "is_process_alive",
+  "is_record",
+  "is_reference",
+  "is_tuple",
+  "length",
+  "link",
+  "list_to_atom",
+  "list_to_binary",
+  "list_to_bitstring",
+  "list_to_existing_atom",
+  "list_to_float",
+  "list_to_integer",
+  "list_to_pid",
+  "list_to_tuple",
+  "load_module",
+  "make_ref",
+  "module_loaded",
+  "monitor_node",
+  "node",
+  "node_link",
+  "node_unlink",
+  "nodes",
+  "notalive",
+  "now",
+  "open_port",
+  "pid_to_list",
+  "port_close",
+  "port_command",
+  "port_connect",
+  "port_control",
+  "pre_loaded",
+  "process_flag",
+  "process_info",
+  "processes",
+  "purge_module",
+  "put",
+  "register",
+  "registered",
+  "round",
+  "self",
+  "setelement",
+  "size",
+  "spawn",
+  "spawn_link",
+  "spawn_monitor",
+  "spawn_opt",
+  "split_binary",
+  "statistics",
+  "term_to_binary",
+  "time",
+  "throw",
+  "tl",
+  "trunc",
+  "tuple_size",
+  "tuple_to_list",
+  "unlink",
+  "unregister",
+  "whereis"
+], f = /[\w@Ø-ÞÀ-Öß-öø-ÿ]/, N = /[0-7]{1,3}|[bdefnrstv\\"']|\^[a-zA-Z]|x[0-9a-zA-Z]{2}|x{[0-9a-zA-Z]+}/;
+function O(t, r) {
+  if (r.in_string)
+    return r.in_string = !k(t), a(r, t, "string");
+  if (r.in_atom)
+    return r.in_atom = !h(t), a(r, t, "atom");
+  if (t.eatSpace())
+    return a(r, t, "whitespace");
+  if (!_(r) && t.match(/-\s*[a-zß-öø-ÿ][\wØ-ÞÀ-Öß-öø-ÿ]*/))
+    return o(t.current(), x) ? a(r, t, "type") : a(r, t, "attribute");
+  var e = t.next();
+  if (e == "%")
+    return t.skipToEnd(), a(r, t, "comment");
+  if (e == ":")
+    return a(r, t, "colon");
+  if (e == "?")
+    return t.eatSpace(), t.eatWhile(f), a(r, t, "macro");
+  if (e == "#")
+    return t.eatSpace(), t.eatWhile(f), a(r, t, "record");
+  if (e == "$")
+    return t.next() == "\\" && !t.match(N) ? a(r, t, "error") : a(r, t, "number");
+  if (e == ".")
+    return a(r, t, "dot");
+  if (e == "'") {
+    if (!(r.in_atom = !h(t))) {
+      if (t.match(/\s*\/\s*[0-9]/, !1))
+        return t.match(/\s*\/\s*[0-9]/, !0), a(r, t, "fun");
+      if (t.match(/\s*\(/, !1) || t.match(/\s*:/, !1))
+        return a(r, t, "function");
+    }
+    return a(r, t, "atom");
+  }
+  if (e == '"')
+    return r.in_string = !k(t), a(r, t, "string");
+  if (/[A-Z_Ø-ÞÀ-Ö]/.test(e))
+    return t.eatWhile(f), a(r, t, "variable");
+  if (/[a-z_ß-öø-ÿ]/.test(e)) {
+    if (t.eatWhile(f), t.match(/\s*\/\s*[0-9]/, !1))
+      return t.match(/\s*\/\s*[0-9]/, !0), a(r, t, "fun");
+    var n = t.current();
+    return o(n, S) ? a(r, t, "keyword") : o(n, U) ? a(r, t, "operator") : t.match(/\s*\(/, !1) ? o(n, D) && (_(r).token != ":" || _(r, 2).token == "erlang") ? a(r, t, "builtin") : o(n, T) ? a(r, t, "guard") : a(r, t, "function") : $(t) == ":" ? n == "erlang" ? a(r, t, "builtin") : a(r, t, "function") : o(n, ["true", "false"]) ? a(r, t, "boolean") : a(r, t, "atom");
+  }
+  var u = /[0-9]/, i = /[0-9a-zA-Z]/;
+  return u.test(e) ? (t.eatWhile(u), t.eat("#") ? t.eatWhile(i) || t.backUp(1) : t.eat(".") && (t.eatWhile(u) ? t.eat(/[eE]/) && (t.eat(/[-+]/) ? t.eatWhile(u) || t.backUp(2) : t.eatWhile(u) || t.backUp(1)) : t.backUp(1)), a(r, t, "number")) : b(t, Z, d) ? a(r, t, "open_paren") : b(t, q, y) ? a(r, t, "close_paren") : g(t, z, W) ? a(r, t, "separator") : g(t, A, E) ? a(r, t, "operator") : a(r, t, null);
+}
+function b(t, r, e) {
+  if (t.current().length == 1 && r.test(t.current())) {
+    for (t.backUp(1); r.test(t.peek()); )
+      if (t.next(), o(t.current(), e))
+        return !0;
+    t.backUp(t.current().length - 1);
+  }
+  return !1;
+}
+function g(t, r, e) {
+  if (t.current().length == 1 && r.test(t.current())) {
+    for (; r.test(t.peek()); )
+      t.next();
+    for (; 0 < t.current().length; ) {
+      if (o(t.current(), e))
+        return !0;
+      t.backUp(1);
+    }
+    t.next();
+  }
+  return !1;
+}
+function k(t) {
+  return v(t, '"', "\\");
+}
+function h(t) {
+  return v(t, "'", "\\");
+}
+function v(t, r, e) {
+  for (; !t.eol(); ) {
+    var n = t.next();
+    if (n == r)
+      return !0;
+    n == e && t.next();
+  }
+  return !1;
+}
+function $(t) {
+  var r = t.match(/^\s*([^\s%])/, !1);
+  return r ? r[1] : "";
+}
+function o(t, r) {
+  return -1 < r.indexOf(t);
+}
+function a(t, r, e) {
+  switch (C(t, j(e, r)), e) {
+    case "atom":
+      return "atom";
+    case "attribute":
+      return "attribute";
+    case "boolean":
+      return "atom";
+    case "builtin":
+      return "builtin";
+    case "close_paren":
+      return null;
+    case "colon":
+      return null;
+    case "comment":
+      return "comment";
+    case "dot":
+      return null;
+    case "error":
+      return "error";
+    case "fun":
+      return "meta";
+    case "function":
+      return "tag";
+    case "guard":
+      return "property";
+    case "keyword":
+      return "keyword";
+    case "macro":
+      return "macroName";
+    case "number":
+      return "number";
+    case "open_paren":
+      return null;
+    case "operator":
+      return "operator";
+    case "record":
+      return "bracket";
+    case "separator":
+      return null;
+    case "string":
+      return "string";
+    case "type":
+      return "def";
+    case "variable":
+      return "variable";
+    default:
+      return null;
+  }
+}
+function w(t, r, e, n) {
+  return {
+    token: t,
+    column: r,
+    indent: e,
+    type: n
+  };
+}
+function j(t, r) {
+  return w(
+    r.current(),
+    r.column(),
+    r.indentation(),
+    t
+  );
+}
+function B(t) {
+  return w(t, 0, 0, t);
+}
+function _(t, r) {
+  var e = t.tokenStack.length, n = r || 1;
+  return e < n ? !1 : t.tokenStack[e - n];
+}
+function C(t, r) {
+  r.type == "comment" || r.type == "whitespace" || (t.tokenStack = F(t.tokenStack, r), t.tokenStack = G(t.tokenStack));
+}
+function F(t, r) {
+  var e = t.length - 1;
+  return 0 < e && t[e].type === "record" && r.type === "dot" ? t.pop() : (0 < e && t[e].type === "group" && t.pop(), t.push(r)), t;
+}
+function G(t) {
+  if (!t.length) return t;
+  var r = t.length - 1;
+  if (t[r].type === "dot")
+    return [];
+  if (r > 1 && t[r].type === "fun" && t[r - 1].token === "fun")
+    return t.slice(0, r - 1);
+  switch (t[r].token) {
+    case "}":
+      return s(t, { g: ["{"] });
+    case "]":
+      return s(t, { i: ["["] });
+    case ")":
+      return s(t, { i: ["("] });
+    case ">>":
+      return s(t, { i: ["<<"] });
+    case "end":
+      return s(t, { i: ["begin", "case", "fun", "if", "receive", "try"] });
+    case ",":
+      return s(t, { e: [
+        "begin",
+        "try",
+        "when",
+        "->",
+        ",",
+        "(",
+        "[",
+        "{",
+        "<<"
+      ] });
+    case "->":
+      return s(t, {
+        r: ["when"],
+        m: ["try", "if", "case", "receive"]
+      });
+    case ";":
+      return s(t, { E: ["case", "fun", "if", "receive", "try", "when"] });
+    case "catch":
+      return s(t, { e: ["try"] });
+    case "of":
+      return s(t, { e: ["case"] });
+    case "after":
+      return s(t, { e: ["receive", "try"] });
+    default:
+      return t;
+  }
+}
+function s(t, r) {
+  for (var e in r)
+    for (var n = t.length - 1, u = r[e], i = n - 1; -1 < i; i--)
+      if (o(t[i].token, u)) {
+        var c = t.slice(0, i);
+        switch (e) {
+          case "m":
+            return c.concat(t[i]).concat(t[n]);
+          case "r":
+            return c.concat(t[n]);
+          case "i":
+            return c;
+          case "g":
+            return c.concat(B("group"));
+          case "E":
+            return c.concat(t[i]);
+          case "e":
+            return c.concat(t[i]);
+        }
+      }
+  return e == "E" ? [] : t;
+}
+function H(t, r, e) {
+  var n, u = I(r), i = _(t, 1), c = _(t, 2);
+  return t.in_string || t.in_atom ? null : c ? i.token == "when" ? i.column + e.unit : u === "when" && c.type === "function" ? c.indent + e.unit : u === "(" && i.token === "fun" ? i.column + 3 : u === "catch" && (n = m(t, ["try"])) ? n.column : o(u, ["end", "after", "of"]) ? (n = m(t, ["begin", "case", "fun", "if", "receive", "try"]), n ? n.column : null) : o(u, y) ? (n = m(t, d), n ? n.column : null) : o(i.token, [",", "|", "||"]) || o(u, [",", "|", "||"]) ? (n = P(t), n ? n.column + n.token.length : e.unit) : i.token == "->" ? o(c.token, ["receive", "case", "if", "try"]) ? c.column + e.unit + e.unit : c.column + e.unit : o(i.token, d) ? i.column + i.token.length : (n = Q(t), l(n) ? n.column + e.unit : 0) : 0;
+}
+function I(t) {
+  var r = t.match(/,|[a-z]+|\}|\]|\)|>>|\|+|\(/);
+  return l(r) && r.index === 0 ? r[0] : "";
+}
+function P(t) {
+  var r = t.tokenStack.slice(0, -1), e = p(r, "type", ["open_paren"]);
+  return l(r[e]) ? r[e] : !1;
+}
+function Q(t) {
+  var r = t.tokenStack, e = p(r, "type", ["open_paren", "separator", "keyword"]), n = p(r, "type", ["operator"]);
+  return l(e) && l(n) && e < n ? r[e + 1] : l(e) ? r[e] : !1;
+}
+function m(t, r) {
+  var e = t.tokenStack, n = p(e, "token", r);
+  return l(e[n]) ? e[n] : !1;
+}
+function p(t, r, e) {
+  for (var n = t.length - 1; -1 < n; n--)
+    if (o(t[n][r], e))
+      return n;
+  return !1;
+}
+function l(t) {
+  return t !== !1 && t != null;
+}
+const R = {
+  name: "erlang",
+  startState() {
+    return {
+      tokenStack: [],
+      in_string: !1,
+      in_atom: !1
+    };
+  },
+  token: O,
+  indent: H,
+  languageData: {
+    commentTokens: { line: "%" }
+  }
+};
+export {
+  R as erlang
+};

package/dist/factor-Clf6BoVk-DBb2EHMF.js

@@ -0,0 +1,65 @@
+import { k as e } from "./simple-mode-mNVtnu0l-BC8mf7KF.js";
+const n = e({
+  start: [
+    // comments
+    { regex: /#?!.*/, token: "comment" },
+    // strings """, multiline --> state
+    { regex: /"""/, token: "string", next: "string3" },
+    { regex: /(STRING:)(\s)/, token: ["keyword", null], next: "string2" },
+    { regex: /\S*?"/, token: "string", next: "string" },
+    // numbers: dec, hex, unicode, bin, fractional, complex
+    { regex: /(?:0x[\d,a-f]+)|(?:0o[0-7]+)|(?:0b[0,1]+)|(?:\-?\d+.?\d*)(?=\s)/, token: "number" },
+    //{regex: /[+-]?/} //fractional
+    // definition: defining word, defined word, etc
+    { regex: /((?:GENERIC)|\:?\:)(\s+)(\S+)(\s+)(\()/, token: ["keyword", null, "def", null, "bracket"], next: "stack" },
+    // method definition: defining word, type, defined word, etc
+    { regex: /(M\:)(\s+)(\S+)(\s+)(\S+)/, token: ["keyword", null, "def", null, "tag"] },
+    // vocabulary using --> state
+    { regex: /USING\:/, token: "keyword", next: "vocabulary" },
+    // vocabulary definition/use
+    { regex: /(USE\:|IN\:)(\s+)(\S+)(?=\s|$)/, token: ["keyword", null, "tag"] },
+    // definition: a defining word, defined word
+    { regex: /(\S+\:)(\s+)(\S+)(?=\s|$)/, token: ["keyword", null, "def"] },
+    // "keywords", incl. ; t f . [ ] { } defining words
+    { regex: /(?:;|\\|t|f|if|loop|while|until|do|PRIVATE>|<PRIVATE|\.|\S*\[|\]|\S*\{|\})(?=\s|$)/, token: "keyword" },
+    // <constructors> and the like
+    { regex: /\S+[\)>\.\*\?]+(?=\s|$)/, token: "builtin" },
+    { regex: /[\)><]+\S+(?=\s|$)/, token: "builtin" },
+    // operators
+    { regex: /(?:[\+\-\=\/\*<>])(?=\s|$)/, token: "keyword" },
+    // any id (?)
+    { regex: /\S+/, token: "variable" },
+    { regex: /\s+|./, token: null }
+  ],
+  vocabulary: [
+    { regex: /;/, token: "keyword", next: "start" },
+    { regex: /\S+/, token: "tag" },
+    { regex: /\s+|./, token: null }
+  ],
+  string: [
+    { regex: /(?:[^\\]|\\.)*?"/, token: "string", next: "start" },
+    { regex: /.*/, token: "string" }
+  ],
+  string2: [
+    { regex: /^;/, token: "keyword", next: "start" },
+    { regex: /.*/, token: "string" }
+  ],
+  string3: [
+    { regex: /(?:[^\\]|\\.)*?"""/, token: "string", next: "start" },
+    { regex: /.*/, token: "string" }
+  ],
+  stack: [
+    { regex: /\)/, token: "bracket", next: "start" },
+    { regex: /--/, token: "bracket" },
+    { regex: /\S+/, token: "meta" },
+    { regex: /\s+|./, token: null }
+  ],
+  languageData: {
+    name: "factor",
+    dontIndentStates: ["start", "vocabulary", "string", "string3", "stack"],
+    commentTokens: { line: "!" }
+  }
+});
+export {
+  n as factor
+};

package/dist/fcl-CPC2WYrI-CuXG3fcK.js

@@ -0,0 +1,103 @@
+var s = {
+  term: !0,
+  method: !0,
+  accu: !0,
+  rule: !0,
+  then: !0,
+  is: !0,
+  and: !0,
+  or: !0,
+  if: !0,
+  default: !0
+}, c = {
+  var_input: !0,
+  var_output: !0,
+  fuzzify: !0,
+  defuzzify: !0,
+  function_block: !0,
+  ruleblock: !0
+}, o = {
+  end_ruleblock: !0,
+  end_defuzzify: !0,
+  end_function_block: !0,
+  end_fuzzify: !0,
+  end_var: !0
+}, d = {
+  true: !0,
+  false: !0,
+  nan: !0,
+  real: !0,
+  min: !0,
+  max: !0,
+  cog: !0,
+  cogs: !0
+}, i = /[+\-*&^%:=<>!|\/]/;
+function a(t, e) {
+  var r = t.next();
+  if (/[\d\.]/.test(r))
+    return r == "." ? t.match(/^[0-9]+([eE][\-+]?[0-9]+)?/) : r == "0" ? t.match(/^[xX][0-9a-fA-F]+/) || t.match(/^0[0-7]+/) : t.match(/^[0-9]*\.?[0-9]*([eE][\-+]?[0-9]+)?/), "number";
+  if (r == "/" || r == "(") {
+    if (t.eat("*"))
+      return e.tokenize = l, l(t, e);
+    if (t.eat("/"))
+      return t.skipToEnd(), "comment";
+  }
+  if (i.test(r))
+    return t.eatWhile(i), "operator";
+  t.eatWhile(/[\w\$_\xa1-\uffff]/);
+  var n = t.current().toLowerCase();
+  return s.propertyIsEnumerable(n) || c.propertyIsEnumerable(n) || o.propertyIsEnumerable(n) ? "keyword" : d.propertyIsEnumerable(n) ? "atom" : "variable";
+}
+function l(t, e) {
+  for (var r = !1, n; n = t.next(); ) {
+    if ((n == "/" || n == ")") && r) {
+      e.tokenize = a;
+      break;
+    }
+    r = n == "*";
+  }
+  return "comment";
+}
+function f(t, e, r, n, u) {
+  this.indented = t, this.column = e, this.type = r, this.align = n, this.prev = u;
+}
+function m(t, e, r) {
+  return t.context = new f(t.indented, e, r, null, t.context);
+}
+function p(t) {
+  if (t.context.prev) {
+    var e = t.context.type;
+    return e == "end_block" && (t.indented = t.context.indented), t.context = t.context.prev;
+  }
+}
+const k = {
+  name: "fcl",
+  startState: function(t) {
+    return {
+      tokenize: null,
+      context: new f(-t, 0, "top", !1),
+      indented: 0,
+      startOfLine: !0
+    };
+  },
+  token: function(t, e) {
+    var r = e.context;
+    if (t.sol() && (r.align == null && (r.align = !1), e.indented = t.indentation(), e.startOfLine = !0), t.eatSpace()) return null;
+    var n = (e.tokenize || a)(t, e);
+    if (n == "comment") return n;
+    r.align == null && (r.align = !0);
+    var u = t.current().toLowerCase();
+    return c.propertyIsEnumerable(u) ? m(e, t.column(), "end_block") : o.propertyIsEnumerable(u) && p(e), e.startOfLine = !1, n;
+  },
+  indent: function(t, e, r) {
+    if (t.tokenize != a && t.tokenize != null) return 0;
+    var n = t.context, u = o.propertyIsEnumerable(e);
+    return n.align ? n.column + (u ? 0 : 1) : n.indented + (u ? 0 : r.unit);
+  },
+  languageData: {
+    commentTokens: { line: "//", block: { open: "(*", close: "*)" } }
+  }
+};
+export {
+  k as fcl
+};