@luxonis/visualizer-protobuf 1.6.2 → 1.7.1

package/dist/groovy-BD9p_7sW.js

@@ -0,0 +1,230 @@
+function words(str) {
+  var obj = {}, words = str.split(" ");
+  for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+  return obj;
+}
+var keywords = words(
+  "abstract as assert boolean break byte case catch char class const continue def default " +
+    "do double else enum extends final finally float for goto if implements import in " +
+    "instanceof int interface long native new package private protected public return " +
+    "short static strictfp super switch synchronized threadsafe throw throws trait transient " +
+    "try void volatile while");
+var blockKeywords = words("catch class def do else enum finally for if interface switch trait try while");
+var standaloneKeywords = words("return break continue");
+var atoms = words("null true false this");
+
+var curPunc;
+function tokenBase(stream, state) {
+  var ch = stream.next();
+  if (ch == '"' || ch == "'") {
+    return startString(ch, stream, state);
+  }
+  if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+    curPunc = ch;
+    return null;
+  }
+  if (/\d/.test(ch)) {
+    stream.eatWhile(/[\w\.]/);
+    if (stream.eat(/eE/)) { stream.eat(/\+\-/); stream.eatWhile(/\d/); }
+    return "number";
+  }
+  if (ch == "/") {
+    if (stream.eat("*")) {
+      state.tokenize.push(tokenComment);
+      return tokenComment(stream, state);
+    }
+    if (stream.eat("/")) {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (expectExpression(state.lastToken, false)) {
+      return startString(ch, stream, state);
+    }
+  }
+  if (ch == "-" && stream.eat(">")) {
+    curPunc = "->";
+    return null;
+  }
+  if (/[+\-*&%=<>!?|\/~]/.test(ch)) {
+    stream.eatWhile(/[+\-*&%=<>|~]/);
+    return "operator";
+  }
+  stream.eatWhile(/[\w\$_]/);
+  if (ch == "@") { stream.eatWhile(/[\w\$_\.]/); return "meta"; }
+  if (state.lastToken == ".") return "property";
+  if (stream.eat(":")) { curPunc = "proplabel"; return "property"; }
+  var cur = stream.current();
+  if (atoms.propertyIsEnumerable(cur)) { return "atom"; }
+  if (keywords.propertyIsEnumerable(cur)) {
+    if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+    else if (standaloneKeywords.propertyIsEnumerable(cur)) curPunc = "standalone";
+    return "keyword";
+  }
+  return "variable";
+}
+tokenBase.isBase = true;
+
+function startString(quote, stream, state) {
+  var tripleQuoted = false;
+  if (quote != "/" && stream.eat(quote)) {
+    if (stream.eat(quote)) tripleQuoted = true;
+    else return "string";
+  }
+  function t(stream, state) {
+    var escaped = false, next, end = !tripleQuoted;
+    while ((next = stream.next()) != null) {
+      if (next == quote && !escaped) {
+        if (!tripleQuoted) { break; }
+        if (stream.match(quote + quote)) { end = true; break; }
+      }
+      if (quote == '"' && next == "$" && !escaped) {
+        if (stream.eat("{")) {
+          state.tokenize.push(tokenBaseUntilBrace());
+          return "string";
+        } else if (stream.match(/^\w/, false)) {
+          state.tokenize.push(tokenVariableDeref);
+          return "string";
+        }
+      }
+      escaped = !escaped && next == "\\";
+    }
+    if (end) state.tokenize.pop();
+    return "string";
+  }
+  state.tokenize.push(t);
+  return t(stream, state);
+}
+
+function tokenBaseUntilBrace() {
+  var depth = 1;
+  function t(stream, state) {
+    if (stream.peek() == "}") {
+      depth--;
+      if (depth == 0) {
+        state.tokenize.pop();
+        return state.tokenize[state.tokenize.length-1](stream, state);
+      }
+    } else if (stream.peek() == "{") {
+      depth++;
+    }
+    return tokenBase(stream, state);
+  }
+  t.isBase = true;
+  return t;
+}
+
+function tokenVariableDeref(stream, state) {
+  var next = stream.match(/^(\.|[\w\$_]+)/);
+  if (!next) {
+    state.tokenize.pop();
+    return state.tokenize[state.tokenize.length-1](stream, state)
+  }
+  return next[0] == "." ? null : "variable"
+}
+
+function tokenComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "/" && maybeEnd) {
+      state.tokenize.pop();
+      break;
+    }
+    maybeEnd = (ch == "*");
+  }
+  return "comment";
+}
+
+function expectExpression(last, newline) {
+  return !last || last == "operator" || last == "->" || /[\.\[\{\(,;:]/.test(last) ||
+    last == "newstatement" || last == "keyword" || last == "proplabel" ||
+    (last == "standalone" && !newline);
+}
+
+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) {
+  return state.context = new Context(state.indented, 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;
+}
+
+// Interface
+
+const groovy = {
+  name: "groovy",
+  startState: function(indentUnit) {
+    return {
+      tokenize: [tokenBase],
+      context: new Context(-indentUnit, 0, "top", false),
+      indented: 0,
+      startOfLine: true,
+      lastToken: null
+    };
+  },
+
+  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;
+      // Automatic semicolon insertion
+      if (ctx.type == "statement" && !expectExpression(state.lastToken, true)) {
+        popContext(state); ctx = state.context;
+      }
+    }
+    if (stream.eatSpace()) return null;
+    curPunc = null;
+    var style = state.tokenize[state.tokenize.length-1](stream, state);
+    if (style == "comment") return style;
+    if (ctx.align == null) ctx.align = true;
+
+    if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
+    // Handle indentation for {x -> \n ... }
+    else if (curPunc == "->" && ctx.type == "statement" && ctx.prev.type == "}") {
+      popContext(state);
+      state.context.align = false;
+    }
+    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" || (ctx.type == "statement" && curPunc == "newstatement"))
+      pushContext(state, stream.column(), "statement");
+    state.startOfLine = false;
+    state.lastToken = curPunc || style;
+    return style;
+  },
+
+  indent: function(state, textAfter, cx) {
+    if (!state.tokenize[state.tokenize.length-1].isBase) return null;
+    var firstChar = textAfter && textAfter.charAt(0), ctx = state.context;
+    if (ctx.type == "statement" && !expectExpression(state.lastToken, true)) ctx = ctx.prev;
+    var closing = firstChar == ctx.type;
+    if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : 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: "*/"}},
+    closeBrackets: {brackets: ["(", "[", "{", "'", '"', "'''", '"""']}
+  }
+};
+
+export { groovy };

package/dist/haskell-BHnm1B83.js

@@ -0,0 +1,239 @@
+function switchState(source, setState, f) {
+  setState(f);
+  return f(source, setState);
+}
+
+// These should all be Unicode extended, as per the Haskell 2010 report
+var smallRE = /[a-z_]/;
+var largeRE = /[A-Z]/;
+var digitRE = /\d/;
+var hexitRE = /[0-9A-Fa-f]/;
+var octitRE = /[0-7]/;
+var idRE = /[a-z_A-Z0-9'\xa1-\uffff]/;
+var symbolRE = /[-!#$%&*+.\/<=>?@\\^|~:]/;
+var specialRE = /[(),;[\]`{}]/;
+var whiteCharRE = /[ \t\v\f]/; // newlines are handled in tokenizer
+
+function normal(source, setState) {
+  if (source.eatWhile(whiteCharRE)) {
+    return null;
+  }
+
+  var ch = source.next();
+  if (specialRE.test(ch)) {
+    if (ch == '{' && source.eat('-')) {
+      var t = "comment";
+      if (source.eat('#')) {
+        t = "meta";
+      }
+      return switchState(source, setState, ncomment(t, 1));
+    }
+    return null;
+  }
+
+  if (ch == '\'') {
+    if (source.eat('\\')) {
+      source.next();  // should handle other escapes here
+    }
+    else {
+      source.next();
+    }
+    if (source.eat('\'')) {
+      return "string";
+    }
+    return "error";
+  }
+
+  if (ch == '"') {
+    return switchState(source, setState, stringLiteral);
+  }
+
+  if (largeRE.test(ch)) {
+    source.eatWhile(idRE);
+    if (source.eat('.')) {
+      return "qualifier";
+    }
+    return "type";
+  }
+
+  if (smallRE.test(ch)) {
+    source.eatWhile(idRE);
+    return "variable";
+  }
+
+  if (digitRE.test(ch)) {
+    if (ch == '0') {
+      if (source.eat(/[xX]/)) {
+        source.eatWhile(hexitRE); // should require at least 1
+        return "integer";
+      }
+      if (source.eat(/[oO]/)) {
+        source.eatWhile(octitRE); // should require at least 1
+        return "number";
+      }
+    }
+    source.eatWhile(digitRE);
+    var t = "number";
+    if (source.match(/^\.\d+/)) {
+      t = "number";
+    }
+    if (source.eat(/[eE]/)) {
+      t = "number";
+      source.eat(/[-+]/);
+      source.eatWhile(digitRE); // should require at least 1
+    }
+    return t;
+  }
+
+  if (ch == "." && source.eat("."))
+    return "keyword";
+
+  if (symbolRE.test(ch)) {
+    if (ch == '-' && source.eat(/-/)) {
+      source.eatWhile(/-/);
+      if (!source.eat(symbolRE)) {
+        source.skipToEnd();
+        return "comment";
+      }
+    }
+    source.eatWhile(symbolRE);
+    return "variable"
+  }
+
+  return "error";
+}
+
+function ncomment(type, nest) {
+  if (nest == 0) {
+    return normal;
+  }
+  return function(source, setState) {
+    var currNest = nest;
+    while (!source.eol()) {
+      var ch = source.next();
+      if (ch == '{' && source.eat('-')) {
+        ++currNest;
+      }
+      else if (ch == '-' && source.eat('}')) {
+        --currNest;
+        if (currNest == 0) {
+          setState(normal);
+          return type;
+        }
+      }
+    }
+    setState(ncomment(type, currNest));
+    return type;
+  };
+}
+
+function stringLiteral(source, setState) {
+  while (!source.eol()) {
+    var ch = source.next();
+    if (ch == '"') {
+      setState(normal);
+      return "string";
+    }
+    if (ch == '\\') {
+      if (source.eol() || source.eat(whiteCharRE)) {
+        setState(stringGap);
+        return "string";
+      }
+      if (source.eat('&')) ;
+      else {
+        source.next(); // should handle other escapes here
+      }
+    }
+  }
+  setState(normal);
+  return "error";
+}
+
+function stringGap(source, setState) {
+  if (source.eat('\\')) {
+    return switchState(source, setState, stringLiteral);
+  }
+  source.next();
+  setState(normal);
+  return "error";
+}
+
+
+var wellKnownWords = (function() {
+  var wkw = {};
+  function setType(t) {
+    return function () {
+      for (var i = 0; i < arguments.length; i++)
+        wkw[arguments[i]] = t;
+    };
+  }
+
+  setType("keyword")(
+    "case", "class", "data", "default", "deriving", "do", "else", "foreign",
+    "if", "import", "in", "infix", "infixl", "infixr", "instance", "let",
+    "module", "newtype", "of", "then", "type", "where", "_");
+
+  setType("keyword")(
+    "\.\.", ":", "::", "=", "\\", "<-", "->", "@", "~", "=>");
+
+  setType("builtin")(
+    "!!", "$!", "$", "&&", "+", "++", "-", ".", "/", "/=", "<", "<*", "<=",
+    "<$>", "<*>", "=<<", "==", ">", ">=", ">>", ">>=", "^", "^^", "||", "*",
+    "*>", "**");
+
+  setType("builtin")(
+    "Applicative", "Bool", "Bounded", "Char", "Double", "EQ", "Either", "Enum",
+    "Eq", "False", "FilePath", "Float", "Floating", "Fractional", "Functor",
+    "GT", "IO", "IOError", "Int", "Integer", "Integral", "Just", "LT", "Left",
+    "Maybe", "Monad", "Nothing", "Num", "Ord", "Ordering", "Rational", "Read",
+    "ReadS", "Real", "RealFloat", "RealFrac", "Right", "Show", "ShowS",
+    "String", "True");
+
+  setType("builtin")(
+    "abs", "acos", "acosh", "all", "and", "any", "appendFile", "asTypeOf",
+    "asin", "asinh", "atan", "atan2", "atanh", "break", "catch", "ceiling",
+    "compare", "concat", "concatMap", "const", "cos", "cosh", "curry",
+    "cycle", "decodeFloat", "div", "divMod", "drop", "dropWhile", "either",
+    "elem", "encodeFloat", "enumFrom", "enumFromThen", "enumFromThenTo",
+    "enumFromTo", "error", "even", "exp", "exponent", "fail", "filter",
+    "flip", "floatDigits", "floatRadix", "floatRange", "floor", "fmap",
+    "foldl", "foldl1", "foldr", "foldr1", "fromEnum", "fromInteger",
+    "fromIntegral", "fromRational", "fst", "gcd", "getChar", "getContents",
+    "getLine", "head", "id", "init", "interact", "ioError", "isDenormalized",
+    "isIEEE", "isInfinite", "isNaN", "isNegativeZero", "iterate", "last",
+    "lcm", "length", "lex", "lines", "log", "logBase", "lookup", "map",
+    "mapM", "mapM_", "max", "maxBound", "maximum", "maybe", "min", "minBound",
+    "minimum", "mod", "negate", "not", "notElem", "null", "odd", "or",
+    "otherwise", "pi", "pred", "print", "product", "properFraction", "pure",
+    "putChar", "putStr", "putStrLn", "quot", "quotRem", "read", "readFile",
+    "readIO", "readList", "readLn", "readParen", "reads", "readsPrec",
+    "realToFrac", "recip", "rem", "repeat", "replicate", "return", "reverse",
+    "round", "scaleFloat", "scanl", "scanl1", "scanr", "scanr1", "seq",
+    "sequence", "sequence_", "show", "showChar", "showList", "showParen",
+    "showString", "shows", "showsPrec", "significand", "signum", "sin",
+    "sinh", "snd", "span", "splitAt", "sqrt", "subtract", "succ", "sum",
+    "tail", "take", "takeWhile", "tan", "tanh", "toEnum", "toInteger",
+    "toRational", "truncate", "uncurry", "undefined", "unlines", "until",
+    "unwords", "unzip", "unzip3", "userError", "words", "writeFile", "zip",
+    "zip3", "zipWith", "zipWith3");
+
+  return wkw;
+})();
+
+const haskell = {
+  name: "haskell",
+  startState: function ()  { return { f: normal }; },
+  copyState:  function (s) { return { f: s.f }; },
+
+  token: function(stream, state) {
+    var t = state.f(stream, function(s) { state.f = s; });
+    var w = stream.current();
+    return wellKnownWords.hasOwnProperty(w) ? wellKnownWords[w] : t;
+  },
+
+  languageData: {
+    commentTokens: {line: "--", block: {open: "{-", close: "-}"}}
+  }
+};
+
+export { haskell };