@aleph-alpha/chat-kit 6.0.0 → 6.1.1

package/dist/cypher-Dlu_3r4V.js

@@ -0,0 +1,121 @@
+var wordRegexp = function(words) {
+  return new RegExp("^(?:" + words.join("|") + ")$", "i");
+};
+var tokenBase = function(stream) {
+  curPunc = null;
+  var ch = stream.next();
+  if (ch === '"') {
+    stream.match(/^.*?"/);
+    return "string";
+  }
+  if (ch === "'") {
+    stream.match(/^.*?'/);
+    return "string";
+  }
+  if (/[{}\(\),\.;\[\]]/.test(ch)) {
+    curPunc = ch;
+    return "punctuation";
+  } else if (ch === "/" && stream.eat("/")) {
+    stream.skipToEnd();
+    return "comment";
+  } else if (operatorChars.test(ch)) {
+    stream.eatWhile(operatorChars);
+    return null;
+  } else {
+    stream.eatWhile(/[_\w\d]/);
+    if (stream.eat(":")) {
+      stream.eatWhile(/[\w\d_\-]/);
+      return "atom";
+    }
+    var word = stream.current();
+    if (funcs.test(word)) return "builtin";
+    if (preds.test(word)) return "def";
+    if (keywords.test(word) || systemKeywords.test(word)) return "keyword";
+    return "variable";
+  }
+};
+var pushContext = function(state, type, col) {
+  return state.context = {
+    prev: state.context,
+    indent: state.indent,
+    col,
+    type
+  };
+};
+var popContext = function(state) {
+  state.indent = state.context.indent;
+  return state.context = state.context.prev;
+};
+var curPunc;
+var funcs = wordRegexp(["abs", "acos", "allShortestPaths", "asin", "atan", "atan2", "avg", "ceil", "coalesce", "collect", "cos", "cot", "count", "degrees", "e", "endnode", "exp", "extract", "filter", "floor", "haversin", "head", "id", "keys", "labels", "last", "left", "length", "log", "log10", "lower", "ltrim", "max", "min", "node", "nodes", "percentileCont", "percentileDisc", "pi", "radians", "rand", "range", "reduce", "rel", "relationship", "relationships", "replace", "reverse", "right", "round", "rtrim", "shortestPath", "sign", "sin", "size", "split", "sqrt", "startnode", "stdev", "stdevp", "str", "substring", "sum", "tail", "tan", "timestamp", "toFloat", "toInt", "toString", "trim", "type", "upper"]);
+var preds = wordRegexp(["all", "and", "any", "contains", "exists", "has", "in", "none", "not", "or", "single", "xor"]);
+var keywords = wordRegexp(["as", "asc", "ascending", "assert", "by", "case", "commit", "constraint", "create", "csv", "cypher", "delete", "desc", "descending", "detach", "distinct", "drop", "else", "end", "ends", "explain", "false", "fieldterminator", "foreach", "from", "headers", "in", "index", "is", "join", "limit", "load", "match", "merge", "null", "on", "optional", "order", "periodic", "profile", "remove", "return", "scan", "set", "skip", "start", "starts", "then", "true", "union", "unique", "unwind", "using", "when", "where", "with", "call", "yield"]);
+var systemKeywords = wordRegexp(["access", "active", "assign", "all", "alter", "as", "catalog", "change", "copy", "create", "constraint", "constraints", "current", "database", "databases", "dbms", "default", "deny", "drop", "element", "elements", "exists", "from", "grant", "graph", "graphs", "if", "index", "indexes", "label", "labels", "management", "match", "name", "names", "new", "node", "nodes", "not", "of", "on", "or", "password", "populated", "privileges", "property", "read", "relationship", "relationships", "remove", "replace", "required", "revoke", "role", "roles", "set", "show", "start", "status", "stop", "suspended", "to", "traverse", "type", "types", "user", "users", "with", "write"]);
+var operatorChars = /[*+\-<>=&|~%^]/;
+const cypher = {
+  name: "cypher",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      context: null,
+      indent: 0,
+      col: 0
+    };
+  },
+  token: function(stream, state) {
+    if (stream.sol()) {
+      if (state.context && state.context.align == null) {
+        state.context.align = false;
+      }
+      state.indent = stream.indentation();
+    }
+    if (stream.eatSpace()) {
+      return null;
+    }
+    var style = state.tokenize(stream, state);
+    if (style !== "comment" && state.context && state.context.align == null && state.context.type !== "pattern") {
+      state.context.align = true;
+    }
+    if (curPunc === "(") {
+      pushContext(state, ")", stream.column());
+    } else if (curPunc === "[") {
+      pushContext(state, "]", stream.column());
+    } else if (curPunc === "{") {
+      pushContext(state, "}", stream.column());
+    } else if (/[\]\}\)]/.test(curPunc)) {
+      while (state.context && state.context.type === "pattern") {
+        popContext(state);
+      }
+      if (state.context && curPunc === state.context.type) {
+        popContext(state);
+      }
+    } else if (curPunc === "." && state.context && state.context.type === "pattern") {
+      popContext(state);
+    } else if (/atom|string|variable/.test(style) && state.context) {
+      if (/[\}\]]/.test(state.context.type)) {
+        pushContext(state, "pattern", stream.column());
+      } else if (state.context.type === "pattern" && !state.context.align) {
+        state.context.align = true;
+        state.context.col = stream.column();
+      }
+    }
+    return style;
+  },
+  indent: function(state, textAfter, cx) {
+    var firstChar = textAfter && textAfter.charAt(0);
+    var context = state.context;
+    if (/[\]\}]/.test(firstChar)) {
+      while (context && context.type === "pattern") {
+        context = context.prev;
+      }
+    }
+    var closing = context && firstChar === context.type;
+    if (!context) return 0;
+    if (context.type === "keywords") return null;
+    if (context.align) return context.col + (closing ? 0 : 1);
+    return context.indent + (closing ? 0 : cx.unit);
+  }
+};
+export {
+  cypher
+};

package/dist/d-UURgV0Ux.js

@@ -0,0 +1,179 @@
+function words(str) {
+  var obj = {}, words2 = str.split(" ");
+  for (var i = 0; i < words2.length; ++i) obj[words2[i]] = true;
+  return obj;
+}
+var blockKeywordsStr = "body catch class do else enum for foreach foreach_reverse if in interface mixin out scope struct switch try union unittest version while with";
+const parserConfig = {
+  keywords: words("abstract alias align asm assert auto break case cast cdouble cent cfloat const continue debug default delegate delete deprecated export extern final finally function goto immutable import inout invariant is lazy macro module new nothrow override package pragma private protected public pure ref return shared short static super synchronized template this throw typedef typeid typeof volatile __FILE__ __LINE__ __gshared __traits __vector __parameters " + blockKeywordsStr),
+  blockKeywords: words(blockKeywordsStr),
+  builtin: words("bool byte char creal dchar double float idouble ifloat int ireal long real short ubyte ucent uint ulong ushort wchar wstring void size_t sizediff_t"),
+  atoms: words("exit failure success true false null"),
+  hooks: {
+    "@": function(stream, _state) {
+      stream.eatWhile(/[\w\$_]/);
+      return "meta";
+    }
+  }
+};
+var statementIndentUnit = parserConfig.statementIndentUnit, keywords = parserConfig.keywords, builtin = parserConfig.builtin, blockKeywords = parserConfig.blockKeywords, atoms = parserConfig.atoms, hooks = parserConfig.hooks, multiLineStrings = parserConfig.multiLineStrings;
+var isOperatorChar = /[+\-*&%=<>!?|\/]/;
+var curPunc;
+function tokenBase(stream, state) {
+  var ch = stream.next();
+  if (hooks[ch]) {
+    var result = hooks[ch](stream, state);
+    if (result !== false) return result;
+  }
+  if (ch == '"' || ch == "'" || ch == "`") {
+    state.tokenize = tokenString(ch);
+    return state.tokenize(stream, state);
+  }
+  if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+    curPunc = ch;
+    return null;
+  }
+  if (/\d/.test(ch)) {
+    stream.eatWhile(/[\w\.]/);
+    return "number";
+  }
+  if (ch == "/") {
+    if (stream.eat("+")) {
+      state.tokenize = tokenNestedComment;
+      return tokenNestedComment(stream, state);
+    }
+    if (stream.eat("*")) {
+      state.tokenize = tokenComment;
+      return tokenComment(stream, state);
+    }
+    if (stream.eat("/")) {
+      stream.skipToEnd();
+      return "comment";
+    }
+  }
+  if (isOperatorChar.test(ch)) {
+    stream.eatWhile(isOperatorChar);
+    return "operator";
+  }
+  stream.eatWhile(/[\w\$_\xa1-\uffff]/);
+  var cur = stream.current();
+  if (keywords.propertyIsEnumerable(cur)) {
+    if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+    return "keyword";
+  }
+  if (builtin.propertyIsEnumerable(cur)) {
+    if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+    return "builtin";
+  }
+  if (atoms.propertyIsEnumerable(cur)) return "atom";
+  return "variable";
+}
+function tokenString(quote) {
+  return function(stream, state) {
+    var escaped = false, next, end = false;
+    while ((next = stream.next()) != null) {
+      if (next == quote && !escaped) {
+        end = true;
+        break;
+      }
+      escaped = !escaped && next == "\\";
+    }
+    if (end || !(escaped || multiLineStrings))
+      state.tokenize = null;
+    return "string";
+  };
+}
+function tokenComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "/" && maybeEnd) {
+      state.tokenize = null;
+      break;
+    }
+    maybeEnd = ch == "*";
+  }
+  return "comment";
+}
+function tokenNestedComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "/" && maybeEnd) {
+      state.tokenize = null;
+      break;
+    }
+    maybeEnd = ch == "+";
+  }
+  return "comment";
+}
+function Context(indented, column, type, align, prev) {
+  this.indented = indented;
+  this.column = column;
+  this.type = type;
+  this.align = align;
+  this.prev = prev;
+}
+function pushContext(state, col, type) {
+  var indent = state.indented;
+  if (state.context && state.context.type == "statement")
+    indent = state.context.indented;
+  return state.context = new Context(indent, col, type, null, state.context);
+}
+function popContext(state) {
+  var t = state.context.type;
+  if (t == ")" || t == "]" || t == "}")
+    state.indented = state.context.indented;
+  return state.context = state.context.prev;
+}
+const d = {
+  name: "d",
+  startState: function(indentUnit) {
+    return {
+      tokenize: null,
+      context: new Context(-indentUnit, 0, "top", false),
+      indented: 0,
+      startOfLine: true
+    };
+  },
+  token: function(stream, state) {
+    var ctx = state.context;
+    if (stream.sol()) {
+      if (ctx.align == null) ctx.align = false;
+      state.indented = stream.indentation();
+      state.startOfLine = true;
+    }
+    if (stream.eatSpace()) return null;
+    curPunc = null;
+    var style = (state.tokenize || tokenBase)(stream, state);
+    if (style == "comment" || style == "meta") return style;
+    if (ctx.align == null) ctx.align = true;
+    if ((curPunc == ";" || curPunc == ":" || curPunc == ",") && ctx.type == "statement") popContext(state);
+    else if (curPunc == "{") pushContext(state, stream.column(), "}");
+    else if (curPunc == "[") pushContext(state, stream.column(), "]");
+    else if (curPunc == "(") pushContext(state, stream.column(), ")");
+    else if (curPunc == "}") {
+      while (ctx.type == "statement") ctx = popContext(state);
+      if (ctx.type == "}") ctx = popContext(state);
+      while (ctx.type == "statement") ctx = popContext(state);
+    } else if (curPunc == ctx.type) popContext(state);
+    else if ((ctx.type == "}" || ctx.type == "top") && curPunc != ";" || ctx.type == "statement" && curPunc == "newstatement")
+      pushContext(state, stream.column(), "statement");
+    state.startOfLine = false;
+    return style;
+  },
+  indent: function(state, textAfter, cx) {
+    if (state.tokenize != tokenBase && state.tokenize != null) return null;
+    var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
+    if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
+    var closing = firstChar == ctx.type;
+    if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : statementIndentUnit || cx.unit);
+    else if (ctx.align) return ctx.column + (closing ? 0 : 1);
+    else return ctx.indented + (closing ? 0 : cx.unit);
+  },
+  languageData: {
+    indentOnInput: /^\s*[{}]$/,
+    commentTokens: { line: "//", block: { open: "/*", close: "*/" } }
+  }
+};
+export {
+  d
+};

package/dist/diff-B_Bi2Crb.js

@@ -0,0 +1,25 @@
+var TOKEN_NAMES = {
+  "+": "inserted",
+  "-": "deleted",
+  "@": "meta"
+};
+const diff = {
+  name: "diff",
+  token: function(stream) {
+    var tw_pos = stream.string.search(/[\t ]+?$/);
+    if (!stream.sol() || tw_pos === 0) {
+      stream.skipToEnd();
+      return ("error " + (TOKEN_NAMES[stream.string.charAt(0)] || "")).replace(/ $/, "");
+    }
+    var token_name = TOKEN_NAMES[stream.peek()] || stream.skipToEnd();
+    if (tw_pos === -1) {
+      stream.skipToEnd();
+    } else {
+      stream.pos = tw_pos;
+    }
+    return token_name;
+  }
+};
+export {
+  diff
+};

package/dist/dockerfile-Bvk733Ga.js

@@ -0,0 +1,201 @@
+import { s as simpleMode } from "./simple-mode-DMneyfDu.js";
+var from = "from";
+var fromRegex = new RegExp("^(\\s*)\\b(" + from + ")\\b", "i");
+var shells = ["run", "cmd", "entrypoint", "shell"];
+var shellsAsArrayRegex = new RegExp("^(\\s*)(" + shells.join("|") + ")(\\s+\\[)", "i");
+var expose = "expose";
+var exposeRegex = new RegExp("^(\\s*)(" + expose + ")(\\s+)", "i");
+var others = [
+  "arg",
+  "from",
+  "maintainer",
+  "label",
+  "env",
+  "add",
+  "copy",
+  "volume",
+  "user",
+  "workdir",
+  "onbuild",
+  "stopsignal",
+  "healthcheck",
+  "shell"
+];
+var instructions = [from, expose].concat(shells).concat(others), instructionRegex = "(" + instructions.join("|") + ")", instructionOnlyLine = new RegExp("^(\\s*)" + instructionRegex + "(\\s*)(#.*)?$", "i"), instructionWithArguments = new RegExp("^(\\s*)" + instructionRegex + "(\\s+)", "i");
+const dockerFile = simpleMode({
+  start: [
+    // Block comment: This is a line starting with a comment
+    {
+      regex: /^\s*#.*$/,
+      sol: true,
+      token: "comment"
+    },
+    {
+      regex: fromRegex,
+      token: [null, "keyword"],
+      sol: true,
+      next: "from"
+    },
+    // Highlight an instruction without any arguments (for convenience)
+    {
+      regex: instructionOnlyLine,
+      token: [null, "keyword", null, "error"],
+      sol: true
+    },
+    {
+      regex: shellsAsArrayRegex,
+      token: [null, "keyword", null],
+      sol: true,
+      next: "array"
+    },
+    {
+      regex: exposeRegex,
+      token: [null, "keyword", null],
+      sol: true,
+      next: "expose"
+    },
+    // Highlight an instruction followed by arguments
+    {
+      regex: instructionWithArguments,
+      token: [null, "keyword", null],
+      sol: true,
+      next: "arguments"
+    },
+    {
+      regex: /./,
+      token: null
+    }
+  ],
+  from: [
+    {
+      regex: /\s*$/,
+      token: null,
+      next: "start"
+    },
+    {
+      // Line comment without instruction arguments is an error
+      regex: /(\s*)(#.*)$/,
+      token: [null, "error"],
+      next: "start"
+    },
+    {
+      regex: /(\s*\S+\s+)(as)/i,
+      token: [null, "keyword"],
+      next: "start"
+    },
+    // Fail safe return to start
+    {
+      token: null,
+      next: "start"
+    }
+  ],
+  single: [
+    {
+      regex: /(?:[^\\']|\\.)/,
+      token: "string"
+    },
+    {
+      regex: /'/,
+      token: "string",
+      pop: true
+    }
+  ],
+  double: [
+    {
+      regex: /(?:[^\\"]|\\.)/,
+      token: "string"
+    },
+    {
+      regex: /"/,
+      token: "string",
+      pop: true
+    }
+  ],
+  array: [
+    {
+      regex: /\]/,
+      token: null,
+      next: "start"
+    },
+    {
+      regex: /"(?:[^\\"]|\\.)*"?/,
+      token: "string"
+    }
+  ],
+  expose: [
+    {
+      regex: /\d+$/,
+      token: "number",
+      next: "start"
+    },
+    {
+      regex: /[^\d]+$/,
+      token: null,
+      next: "start"
+    },
+    {
+      regex: /\d+/,
+      token: "number"
+    },
+    {
+      regex: /[^\d]+/,
+      token: null
+    },
+    // Fail safe return to start
+    {
+      token: null,
+      next: "start"
+    }
+  ],
+  arguments: [
+    {
+      regex: /^\s*#.*$/,
+      sol: true,
+      token: "comment"
+    },
+    {
+      regex: /"(?:[^\\"]|\\.)*"?$/,
+      token: "string",
+      next: "start"
+    },
+    {
+      regex: /"/,
+      token: "string",
+      push: "double"
+    },
+    {
+      regex: /'(?:[^\\']|\\.)*'?$/,
+      token: "string",
+      next: "start"
+    },
+    {
+      regex: /'/,
+      token: "string",
+      push: "single"
+    },
+    {
+      regex: /[^#"']+[\\`]$/,
+      token: null
+    },
+    {
+      regex: /[^#"']+$/,
+      token: null,
+      next: "start"
+    },
+    {
+      regex: /[^#"']+/,
+      token: null
+    },
+    // Fail safe return to start
+    {
+      token: null,
+      next: "start"
+    }
+  ],
+  languageData: {
+    commentTokens: { line: "#" }
+  }
+});
+export {
+  dockerFile
+};

package/dist/dtd-Dy74G54E.js

@@ -0,0 +1,114 @@
+var type;
+function ret(style, tp) {
+  type = tp;
+  return style;
+}
+function tokenBase(stream, state) {
+  var ch = stream.next();
+  if (ch == "<" && stream.eat("!")) {
+    if (stream.eatWhile(/[\-]/)) {
+      state.tokenize = tokenSGMLComment;
+      return tokenSGMLComment(stream, state);
+    } else if (stream.eatWhile(/[\w]/)) return ret("keyword", "doindent");
+  } else if (ch == "<" && stream.eat("?")) {
+    state.tokenize = inBlock("meta", "?>");
+    return ret("meta", ch);
+  } else if (ch == "#" && stream.eatWhile(/[\w]/)) return ret("atom", "tag");
+  else if (ch == "|") return ret("keyword", "separator");
+  else if (ch.match(/[\(\)\[\]\-\.,\+\?>]/)) return ret(null, ch);
+  else if (ch.match(/[\[\]]/)) return ret("rule", ch);
+  else if (ch == '"' || ch == "'") {
+    state.tokenize = tokenString(ch);
+    return state.tokenize(stream, state);
+  } else if (stream.eatWhile(/[a-zA-Z\?\+\d]/)) {
+    var sc = stream.current();
+    if (sc.substr(sc.length - 1, sc.length).match(/\?|\+/) !== null) stream.backUp(1);
+    return ret("tag", "tag");
+  } else if (ch == "%" || ch == "*") return ret("number", "number");
+  else {
+    stream.eatWhile(/[\w\\\-_%.{,]/);
+    return ret(null, null);
+  }
+}
+function tokenSGMLComment(stream, state) {
+  var dashes = 0, ch;
+  while ((ch = stream.next()) != null) {
+    if (dashes >= 2 && ch == ">") {
+      state.tokenize = tokenBase;
+      break;
+    }
+    dashes = ch == "-" ? dashes + 1 : 0;
+  }
+  return ret("comment", "comment");
+}
+function tokenString(quote) {
+  return function(stream, state) {
+    var escaped = false, ch;
+    while ((ch = stream.next()) != null) {
+      if (ch == quote && !escaped) {
+        state.tokenize = tokenBase;
+        break;
+      }
+      escaped = !escaped && ch == "\\";
+    }
+    return ret("string", "tag");
+  };
+}
+function inBlock(style, terminator) {
+  return function(stream, state) {
+    while (!stream.eol()) {
+      if (stream.match(terminator)) {
+        state.tokenize = tokenBase;
+        break;
+      }
+      stream.next();
+    }
+    return style;
+  };
+}
+const dtd = {
+  name: "dtd",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      baseIndent: 0,
+      stack: []
+    };
+  },
+  token: function(stream, state) {
+    if (stream.eatSpace()) return null;
+    var style = state.tokenize(stream, state);
+    var context = state.stack[state.stack.length - 1];
+    if (stream.current() == "[" || type === "doindent" || type == "[") state.stack.push("rule");
+    else if (type === "endtag") state.stack[state.stack.length - 1] = "endtag";
+    else if (stream.current() == "]" || type == "]" || type == ">" && context == "rule") state.stack.pop();
+    else if (type == "[") state.stack.push("[");
+    return style;
+  },
+  indent: function(state, textAfter, cx) {
+    var n = state.stack.length;
+    if (textAfter.charAt(0) === "]") n--;
+    else if (textAfter.substr(textAfter.length - 1, textAfter.length) === ">") {
+      if (textAfter.substr(0, 1) === "<") ;
+      else if (type == "doindent" && textAfter.length > 1) ;
+      else if (type == "doindent") n--;
+      else if (type == ">" && textAfter.length > 1) ;
+      else if (type == "tag" && textAfter !== ">") ;
+      else if (type == "tag" && state.stack[state.stack.length - 1] == "rule") n--;
+      else if (type == "tag") n++;
+      else if (textAfter === ">" && state.stack[state.stack.length - 1] == "rule" && type === ">") n--;
+      else if (textAfter === ">" && state.stack[state.stack.length - 1] == "rule") ;
+      else if (textAfter.substr(0, 1) !== "<" && textAfter.substr(0, 1) === ">") n = n - 1;
+      else if (textAfter === ">") ;
+      else n = n - 1;
+      if (type == null || type == "]") n--;
+    }
+    return state.baseIndent + n * cx.unit;
+  },
+  languageData: {
+    indentOnInput: /^\s*[\]>]$/
+  }
+};
+export {
+  dtd
+};