@luxonis/visualizer-protobuf 1.6.2 → 1.7.1

package/dist/coffeescript-BG8vTfSz.js

@@ -0,0 +1,329 @@
+var ERRORCLASS = "error";
+
+function wordRegexp(words) {
+  return new RegExp("^((" + words.join(")|(") + "))\\b");
+}
+
+var operators = /^(?:->|=>|\+[+=]?|-[\-=]?|\*[\*=]?|\/[\/=]?|[=!]=|<[><]?=?|>>?=?|%=?|&=?|\|=?|\^=?|\~|!|\?|(or|and|\|\||&&|\?)=)/;
+var delimiters = /^(?:[()\[\]{},:`=;]|\.\.?\.?)/;
+var identifiers = /^[_A-Za-z$][_A-Za-z$0-9]*/;
+var atProp = /^@[_A-Za-z$][_A-Za-z$0-9]*/;
+
+var wordOperators = wordRegexp(["and", "or", "not",
+                                "is", "isnt", "in",
+                                "instanceof", "typeof"]);
+var indentKeywords = ["for", "while", "loop", "if", "unless", "else",
+                      "switch", "try", "catch", "finally", "class"];
+var commonKeywords = ["break", "by", "continue", "debugger", "delete",
+                      "do", "in", "of", "new", "return", "then",
+                      "this", "@", "throw", "when", "until", "extends"];
+
+var keywords = wordRegexp(indentKeywords.concat(commonKeywords));
+
+indentKeywords = wordRegexp(indentKeywords);
+
+
+var stringPrefixes = /^('{3}|\"{3}|['\"])/;
+var regexPrefixes = /^(\/{3}|\/)/;
+var commonConstants = ["Infinity", "NaN", "undefined", "null", "true", "false", "on", "off", "yes", "no"];
+var constants = wordRegexp(commonConstants);
+
+// Tokenizers
+function tokenBase(stream, state) {
+  // Handle scope changes
+  if (stream.sol()) {
+    if (state.scope.align === null) state.scope.align = false;
+    var scopeOffset = state.scope.offset;
+    if (stream.eatSpace()) {
+      var lineOffset = stream.indentation();
+      if (lineOffset > scopeOffset && state.scope.type == "coffee") {
+        return "indent";
+      } else if (lineOffset < scopeOffset) {
+        return "dedent";
+      }
+      return null;
+    } else {
+      if (scopeOffset > 0) {
+        dedent(stream, state);
+      }
+    }
+  }
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  var ch = stream.peek();
+
+  // Handle docco title comment (single line)
+  if (stream.match("####")) {
+    stream.skipToEnd();
+    return "comment";
+  }
+
+  // Handle multi line comments
+  if (stream.match("###")) {
+    state.tokenize = longComment;
+    return state.tokenize(stream, state);
+  }
+
+  // Single line comment
+  if (ch === "#") {
+    stream.skipToEnd();
+    return "comment";
+  }
+
+  // Handle number literals
+  if (stream.match(/^-?[0-9\.]/, false)) {
+    var floatLiteral = false;
+    // Floats
+    if (stream.match(/^-?\d*\.\d+(e[\+\-]?\d+)?/i)) {
+      floatLiteral = true;
+    }
+    if (stream.match(/^-?\d+\.\d*/)) {
+      floatLiteral = true;
+    }
+    if (stream.match(/^-?\.\d+/)) {
+      floatLiteral = true;
+    }
+
+    if (floatLiteral) {
+      // prevent from getting extra . on 1..
+      if (stream.peek() == "."){
+        stream.backUp(1);
+      }
+      return "number";
+    }
+    // Integers
+    var intLiteral = false;
+    // Hex
+    if (stream.match(/^-?0x[0-9a-f]+/i)) {
+      intLiteral = true;
+    }
+    // Decimal
+    if (stream.match(/^-?[1-9]\d*(e[\+\-]?\d+)?/)) {
+      intLiteral = true;
+    }
+    // Zero by itself with no other piece of number.
+    if (stream.match(/^-?0(?![\dx])/i)) {
+      intLiteral = true;
+    }
+    if (intLiteral) {
+      return "number";
+    }
+  }
+
+  // Handle strings
+  if (stream.match(stringPrefixes)) {
+    state.tokenize = tokenFactory(stream.current(), false, "string");
+    return state.tokenize(stream, state);
+  }
+  // Handle regex literals
+  if (stream.match(regexPrefixes)) {
+    if (stream.current() != "/" || stream.match(/^.*\//, false)) { // prevent highlight of division
+      state.tokenize = tokenFactory(stream.current(), true, "string.special");
+      return state.tokenize(stream, state);
+    } else {
+      stream.backUp(1);
+    }
+  }
+
+
+
+  // Handle operators and delimiters
+  if (stream.match(operators) || stream.match(wordOperators)) {
+    return "operator";
+  }
+  if (stream.match(delimiters)) {
+    return "punctuation";
+  }
+
+  if (stream.match(constants)) {
+    return "atom";
+  }
+
+  if (stream.match(atProp) || state.prop && stream.match(identifiers)) {
+    return "property";
+  }
+
+  if (stream.match(keywords)) {
+    return "keyword";
+  }
+
+  if (stream.match(identifiers)) {
+    return "variable";
+  }
+
+  // Handle non-detected items
+  stream.next();
+  return ERRORCLASS;
+}
+
+function tokenFactory(delimiter, singleline, outclass) {
+  return function(stream, state) {
+    while (!stream.eol()) {
+      stream.eatWhile(/[^'"\/\\]/);
+      if (stream.eat("\\")) {
+        stream.next();
+        if (singleline && stream.eol()) {
+          return outclass;
+        }
+      } else if (stream.match(delimiter)) {
+        state.tokenize = tokenBase;
+        return outclass;
+      } else {
+        stream.eat(/['"\/]/);
+      }
+    }
+    if (singleline) {
+      state.tokenize = tokenBase;
+    }
+    return outclass;
+  };
+}
+
+function longComment(stream, state) {
+  while (!stream.eol()) {
+    stream.eatWhile(/[^#]/);
+    if (stream.match("###")) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    stream.eatWhile("#");
+  }
+  return "comment";
+}
+
+function indent(stream, state, type = "coffee") {
+  var offset = 0, align = false, alignOffset = null;
+  for (var scope = state.scope; scope; scope = scope.prev) {
+    if (scope.type === "coffee" || scope.type == "}") {
+      offset = scope.offset + stream.indentUnit;
+      break;
+    }
+  }
+  if (type !== "coffee") {
+    align = null;
+    alignOffset = stream.column() + stream.current().length;
+  } else if (state.scope.align) {
+    state.scope.align = false;
+  }
+  state.scope = {
+    offset: offset,
+    type: type,
+    prev: state.scope,
+    align: align,
+    alignOffset: alignOffset
+  };
+}
+
+function dedent(stream, state) {
+  if (!state.scope.prev) return;
+  if (state.scope.type === "coffee") {
+    var _indent = stream.indentation();
+    var matched = false;
+    for (var scope = state.scope; scope; scope = scope.prev) {
+      if (_indent === scope.offset) {
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      return true;
+    }
+    while (state.scope.prev && state.scope.offset !== _indent) {
+      state.scope = state.scope.prev;
+    }
+    return false;
+  } else {
+    state.scope = state.scope.prev;
+    return false;
+  }
+}
+
+function tokenLexer(stream, state) {
+  var style = state.tokenize(stream, state);
+  var current = stream.current();
+
+  // Handle scope changes.
+  if (current === "return") {
+    state.dedent = true;
+  }
+  if (((current === "->" || current === "=>") && stream.eol())
+      || style === "indent") {
+    indent(stream, state);
+  }
+  var delimiter_index = "[({".indexOf(current);
+  if (delimiter_index !== -1) {
+    indent(stream, state, "])}".slice(delimiter_index, delimiter_index+1));
+  }
+  if (indentKeywords.exec(current)){
+    indent(stream, state);
+  }
+  if (current == "then"){
+    dedent(stream, state);
+  }
+
+
+  if (style === "dedent") {
+    if (dedent(stream, state)) {
+      return ERRORCLASS;
+    }
+  }
+  delimiter_index = "])}".indexOf(current);
+  if (delimiter_index !== -1) {
+    while (state.scope.type == "coffee" && state.scope.prev)
+      state.scope = state.scope.prev;
+    if (state.scope.type == current)
+      state.scope = state.scope.prev;
+  }
+  if (state.dedent && stream.eol()) {
+    if (state.scope.type == "coffee" && state.scope.prev)
+      state.scope = state.scope.prev;
+    state.dedent = false;
+  }
+
+  return style == "indent" || style == "dedent" ? null : style;
+}
+
+const coffeeScript = {
+  name: "coffeescript",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      scope: {offset: 0, type:"coffee", prev: null, align: false},
+      prop: false,
+      dedent: 0
+    };
+  },
+
+  token: function(stream, state) {
+    var fillAlign = state.scope.align === null && state.scope;
+    if (fillAlign && stream.sol()) fillAlign.align = false;
+
+    var style = tokenLexer(stream, state);
+    if (style && style != "comment") {
+      if (fillAlign) fillAlign.align = true;
+      state.prop = style == "punctuation" && stream.current() == ".";
+    }
+
+    return style;
+  },
+
+  indent: function(state, text) {
+    if (state.tokenize != tokenBase) return 0;
+    var scope = state.scope;
+    var closer = text && "])}".indexOf(text.charAt(0)) > -1;
+    if (closer) while (scope.type == "coffee" && scope.prev) scope = scope.prev;
+    var closes = closer && scope.type === text.charAt(0);
+    if (scope.align)
+      return scope.alignOffset - (closes ? 1 : 0);
+    else
+      return (closes ? scope.prev : scope).offset;
+  },
+
+  languageData: {
+    commentTokens: {line: "#"}
+  }
+};
+
+export { coffeeScript };

package/dist/commonlisp-8oE2EpEe.js

@@ -0,0 +1,108 @@
+var specialForm = /^(block|let*|return-from|catch|load-time-value|setq|eval-when|locally|symbol-macrolet|flet|macrolet|tagbody|function|multiple-value-call|the|go|multiple-value-prog1|throw|if|progn|unwind-protect|labels|progv|let|quote)$/;
+var assumeBody = /^with|^def|^do|^prog|case$|^cond$|bind$|when$|unless$/;
+var numLiteral = /^(?:[+\-]?(?:\d+|\d*\.\d+)(?:[efd][+\-]?\d+)?|[+\-]?\d+(?:\/[+\-]?\d+)?|#b[+\-]?[01]+|#o[+\-]?[0-7]+|#x[+\-]?[\da-f]+)/;
+var symbol = /[^\s'`,@()\[\]";]/;
+var type;
+
+function readSym(stream) {
+  var ch;
+  while (ch = stream.next()) {
+    if (ch == "\\") stream.next();
+    else if (!symbol.test(ch)) { stream.backUp(1); break; }
+  }
+  return stream.current();
+}
+
+function base(stream, state) {
+  if (stream.eatSpace()) {type = "ws"; return null;}
+  if (stream.match(numLiteral)) return "number";
+  var ch = stream.next();
+  if (ch == "\\") ch = stream.next();
+
+  if (ch == '"') return (state.tokenize = inString)(stream, state);
+  else if (ch == "(") { type = "open"; return "bracket"; }
+  else if (ch == ")") { type = "close"; return "bracket"; }
+  else if (ch == ";") { stream.skipToEnd(); type = "ws"; return "comment"; }
+  else if (/['`,@]/.test(ch)) return null;
+  else if (ch == "|") {
+    if (stream.skipTo("|")) { stream.next(); return "variableName"; }
+    else { stream.skipToEnd(); return "error"; }
+  } else if (ch == "#") {
+    var ch = stream.next();
+    if (ch == "(") { type = "open"; return "bracket"; }
+    else if (/[+\-=\.']/.test(ch)) return null;
+    else if (/\d/.test(ch) && stream.match(/^\d*#/)) return null;
+    else if (ch == "|") return (state.tokenize = inComment)(stream, state);
+    else if (ch == ":") { readSym(stream); return "meta"; }
+    else if (ch == "\\") { stream.next(); readSym(stream); return "string.special" }
+    else return "error";
+  } else {
+    var name = readSym(stream);
+    if (name == ".") return null;
+    type = "symbol";
+    if (name == "nil" || name == "t" || name.charAt(0) == ":") return "atom";
+    if (state.lastType == "open" && (specialForm.test(name) || assumeBody.test(name))) return "keyword";
+    if (name.charAt(0) == "&") return "variableName.special";
+    return "variableName";
+  }
+}
+
+function inString(stream, state) {
+  var escaped = false, next;
+  while (next = stream.next()) {
+    if (next == '"' && !escaped) { state.tokenize = base; break; }
+    escaped = !escaped && next == "\\";
+  }
+  return "string";
+}
+
+function inComment(stream, state) {
+  var next, last;
+  while (next = stream.next()) {
+    if (next == "#" && last == "|") { state.tokenize = base; break; }
+    last = next;
+  }
+  type = "ws";
+  return "comment";
+}
+
+const commonLisp = {
+  name: "commonlisp",
+  startState: function () {
+    return {ctx: {prev: null, start: 0, indentTo: 0}, lastType: null, tokenize: base};
+  },
+
+  token: function (stream, state) {
+    if (stream.sol() && typeof state.ctx.indentTo != "number")
+      state.ctx.indentTo = state.ctx.start + 1;
+
+    type = null;
+    var style = state.tokenize(stream, state);
+    if (type != "ws") {
+      if (state.ctx.indentTo == null) {
+        if (type == "symbol" && assumeBody.test(stream.current()))
+          state.ctx.indentTo = state.ctx.start + stream.indentUnit;
+        else
+          state.ctx.indentTo = "next";
+      } else if (state.ctx.indentTo == "next") {
+        state.ctx.indentTo = stream.column();
+      }
+      state.lastType = type;
+    }
+    if (type == "open") state.ctx = {prev: state.ctx, start: stream.column(), indentTo: null};
+    else if (type == "close") state.ctx = state.ctx.prev || state.ctx;
+    return style;
+  },
+
+  indent: function (state) {
+    var i = state.ctx.indentTo;
+    return typeof i == "number" ? i : state.ctx.start + 1;
+  },
+
+  languageData: {
+    commentTokens: {line: ";;", block: {open: "#|", close: "|#"}},
+    closeBrackets: {brackets: ["(", "[", "{", '"']}
+  }
+};
+
+export { commonLisp };