@openspecui/web 0.9.0 → 0.9.3

package/dist-ssg/server/assets/vbscript-Bfn8O8I7.js

@@ -0,0 +1,478 @@
+function mkVBScript(parserConf) {
+  var ERRORCLASS = "error";
+  function wordRegexp(words) {
+    return new RegExp("^((" + words.join(")|(") + "))\\b", "i");
+  }
+  var singleOperators = new RegExp("^[\\+\\-\\*/&\\\\\\^<>=]");
+  var doubleOperators = new RegExp("^((<>)|(<=)|(>=))");
+  var singleDelimiters = new RegExp("^[\\.,]");
+  var brackets = new RegExp("^[\\(\\)]");
+  var identifiers = new RegExp("^[A-Za-z][_A-Za-z0-9]*");
+  var openingKeywords = ["class", "sub", "select", "while", "if", "function", "property", "with", "for"];
+  var middleKeywords = ["else", "elseif", "case"];
+  var endKeywords = ["next", "loop", "wend"];
+  var wordOperators = wordRegexp(["and", "or", "not", "xor", "is", "mod", "eqv", "imp"]);
+  var commonkeywords = [
+    "dim",
+    "redim",
+    "then",
+    "until",
+    "randomize",
+    "byval",
+    "byref",
+    "new",
+    "property",
+    "exit",
+    "in",
+    "const",
+    "private",
+    "public",
+    "get",
+    "set",
+    "let",
+    "stop",
+    "on error resume next",
+    "on error goto 0",
+    "option explicit",
+    "call",
+    "me"
+  ];
+  var atomWords = ["true", "false", "nothing", "empty", "null"];
+  var builtinFuncsWords = [
+    "abs",
+    "array",
+    "asc",
+    "atn",
+    "cbool",
+    "cbyte",
+    "ccur",
+    "cdate",
+    "cdbl",
+    "chr",
+    "cint",
+    "clng",
+    "cos",
+    "csng",
+    "cstr",
+    "date",
+    "dateadd",
+    "datediff",
+    "datepart",
+    "dateserial",
+    "datevalue",
+    "day",
+    "escape",
+    "eval",
+    "execute",
+    "exp",
+    "filter",
+    "formatcurrency",
+    "formatdatetime",
+    "formatnumber",
+    "formatpercent",
+    "getlocale",
+    "getobject",
+    "getref",
+    "hex",
+    "hour",
+    "inputbox",
+    "instr",
+    "instrrev",
+    "int",
+    "fix",
+    "isarray",
+    "isdate",
+    "isempty",
+    "isnull",
+    "isnumeric",
+    "isobject",
+    "join",
+    "lbound",
+    "lcase",
+    "left",
+    "len",
+    "loadpicture",
+    "log",
+    "ltrim",
+    "rtrim",
+    "trim",
+    "maths",
+    "mid",
+    "minute",
+    "month",
+    "monthname",
+    "msgbox",
+    "now",
+    "oct",
+    "replace",
+    "rgb",
+    "right",
+    "rnd",
+    "round",
+    "scriptengine",
+    "scriptenginebuildversion",
+    "scriptenginemajorversion",
+    "scriptengineminorversion",
+    "second",
+    "setlocale",
+    "sgn",
+    "sin",
+    "space",
+    "split",
+    "sqr",
+    "strcomp",
+    "string",
+    "strreverse",
+    "tan",
+    "time",
+    "timer",
+    "timeserial",
+    "timevalue",
+    "typename",
+    "ubound",
+    "ucase",
+    "unescape",
+    "vartype",
+    "weekday",
+    "weekdayname",
+    "year"
+  ];
+  var builtinConsts = [
+    "vbBlack",
+    "vbRed",
+    "vbGreen",
+    "vbYellow",
+    "vbBlue",
+    "vbMagenta",
+    "vbCyan",
+    "vbWhite",
+    "vbBinaryCompare",
+    "vbTextCompare",
+    "vbSunday",
+    "vbMonday",
+    "vbTuesday",
+    "vbWednesday",
+    "vbThursday",
+    "vbFriday",
+    "vbSaturday",
+    "vbUseSystemDayOfWeek",
+    "vbFirstJan1",
+    "vbFirstFourDays",
+    "vbFirstFullWeek",
+    "vbGeneralDate",
+    "vbLongDate",
+    "vbShortDate",
+    "vbLongTime",
+    "vbShortTime",
+    "vbObjectError",
+    "vbOKOnly",
+    "vbOKCancel",
+    "vbAbortRetryIgnore",
+    "vbYesNoCancel",
+    "vbYesNo",
+    "vbRetryCancel",
+    "vbCritical",
+    "vbQuestion",
+    "vbExclamation",
+    "vbInformation",
+    "vbDefaultButton1",
+    "vbDefaultButton2",
+    "vbDefaultButton3",
+    "vbDefaultButton4",
+    "vbApplicationModal",
+    "vbSystemModal",
+    "vbOK",
+    "vbCancel",
+    "vbAbort",
+    "vbRetry",
+    "vbIgnore",
+    "vbYes",
+    "vbNo",
+    "vbCr",
+    "VbCrLf",
+    "vbFormFeed",
+    "vbLf",
+    "vbNewLine",
+    "vbNullChar",
+    "vbNullString",
+    "vbTab",
+    "vbVerticalTab",
+    "vbUseDefault",
+    "vbTrue",
+    "vbFalse",
+    "vbEmpty",
+    "vbNull",
+    "vbInteger",
+    "vbLong",
+    "vbSingle",
+    "vbDouble",
+    "vbCurrency",
+    "vbDate",
+    "vbString",
+    "vbObject",
+    "vbError",
+    "vbBoolean",
+    "vbVariant",
+    "vbDataObject",
+    "vbDecimal",
+    "vbByte",
+    "vbArray"
+  ];
+  var builtinObjsWords = ["WScript", "err", "debug", "RegExp"];
+  var knownProperties = ["description", "firstindex", "global", "helpcontext", "helpfile", "ignorecase", "length", "number", "pattern", "source", "value", "count"];
+  var knownMethods = ["clear", "execute", "raise", "replace", "test", "write", "writeline", "close", "open", "state", "eof", "update", "addnew", "end", "createobject", "quit"];
+  var aspBuiltinObjsWords = ["server", "response", "request", "session", "application"];
+  var aspKnownProperties = [
+    "buffer",
+    "cachecontrol",
+    "charset",
+    "contenttype",
+    "expires",
+    "expiresabsolute",
+    "isclientconnected",
+    "pics",
+    "status",
+    //response
+    "clientcertificate",
+    "cookies",
+    "form",
+    "querystring",
+    "servervariables",
+    "totalbytes",
+    //request
+    "contents",
+    "staticobjects",
+    //application
+    "codepage",
+    "lcid",
+    "sessionid",
+    "timeout",
+    //session
+    "scripttimeout"
+  ];
+  var aspKnownMethods = [
+    "addheader",
+    "appendtolog",
+    "binarywrite",
+    "end",
+    "flush",
+    "redirect",
+    //response
+    "binaryread",
+    //request
+    "remove",
+    "removeall",
+    "lock",
+    "unlock",
+    //application
+    "abandon",
+    //session
+    "getlasterror",
+    "htmlencode",
+    "mappath",
+    "transfer",
+    "urlencode"
+  ];
+  var knownWords = knownMethods.concat(knownProperties);
+  builtinObjsWords = builtinObjsWords.concat(builtinConsts);
+  if (parserConf.isASP) {
+    builtinObjsWords = builtinObjsWords.concat(aspBuiltinObjsWords);
+    knownWords = knownWords.concat(aspKnownMethods, aspKnownProperties);
+  }
+  var keywords = wordRegexp(commonkeywords);
+  var atoms = wordRegexp(atomWords);
+  var builtinFuncs = wordRegexp(builtinFuncsWords);
+  var builtinObjs = wordRegexp(builtinObjsWords);
+  var known = wordRegexp(knownWords);
+  var stringPrefixes = '"';
+  var opening = wordRegexp(openingKeywords);
+  var middle = wordRegexp(middleKeywords);
+  var closing = wordRegexp(endKeywords);
+  var doubleClosing = wordRegexp(["end"]);
+  var doOpening = wordRegexp(["do"]);
+  var noIndentWords = wordRegexp(["on error resume next", "exit"]);
+  var comment = wordRegexp(["rem"]);
+  function indent(_stream, state) {
+    state.currentIndent++;
+  }
+  function dedent(_stream, state) {
+    state.currentIndent--;
+  }
+  function tokenBase(stream, state) {
+    if (stream.eatSpace()) {
+      return null;
+    }
+    var ch = stream.peek();
+    if (ch === "'") {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (stream.match(comment)) {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (stream.match(/^((&H)|(&O))?[0-9\.]/i, false) && !stream.match(/^((&H)|(&O))?[0-9\.]+[a-z_]/i, false)) {
+      var floatLiteral = false;
+      if (stream.match(/^\d*\.\d+/i)) {
+        floatLiteral = true;
+      } else if (stream.match(/^\d+\.\d*/)) {
+        floatLiteral = true;
+      } else if (stream.match(/^\.\d+/)) {
+        floatLiteral = true;
+      }
+      if (floatLiteral) {
+        stream.eat(/J/i);
+        return "number";
+      }
+      var intLiteral = false;
+      if (stream.match(/^&H[0-9a-f]+/i)) {
+        intLiteral = true;
+      } else if (stream.match(/^&O[0-7]+/i)) {
+        intLiteral = true;
+      } else if (stream.match(/^[1-9]\d*F?/)) {
+        stream.eat(/J/i);
+        intLiteral = true;
+      } else if (stream.match(/^0(?![\dx])/i)) {
+        intLiteral = true;
+      }
+      if (intLiteral) {
+        stream.eat(/L/i);
+        return "number";
+      }
+    }
+    if (stream.match(stringPrefixes)) {
+      state.tokenize = tokenStringFactory(stream.current());
+      return state.tokenize(stream, state);
+    }
+    if (stream.match(doubleOperators) || stream.match(singleOperators) || stream.match(wordOperators)) {
+      return "operator";
+    }
+    if (stream.match(singleDelimiters)) {
+      return null;
+    }
+    if (stream.match(brackets)) {
+      return "bracket";
+    }
+    if (stream.match(noIndentWords)) {
+      state.doInCurrentLine = true;
+      return "keyword";
+    }
+    if (stream.match(doOpening)) {
+      indent(stream, state);
+      state.doInCurrentLine = true;
+      return "keyword";
+    }
+    if (stream.match(opening)) {
+      if (!state.doInCurrentLine)
+        indent(stream, state);
+      else
+        state.doInCurrentLine = false;
+      return "keyword";
+    }
+    if (stream.match(middle)) {
+      return "keyword";
+    }
+    if (stream.match(doubleClosing)) {
+      dedent(stream, state);
+      dedent(stream, state);
+      return "keyword";
+    }
+    if (stream.match(closing)) {
+      if (!state.doInCurrentLine)
+        dedent(stream, state);
+      else
+        state.doInCurrentLine = false;
+      return "keyword";
+    }
+    if (stream.match(keywords)) {
+      return "keyword";
+    }
+    if (stream.match(atoms)) {
+      return "atom";
+    }
+    if (stream.match(known)) {
+      return "variableName.special";
+    }
+    if (stream.match(builtinFuncs)) {
+      return "builtin";
+    }
+    if (stream.match(builtinObjs)) {
+      return "builtin";
+    }
+    if (stream.match(identifiers)) {
+      return "variable";
+    }
+    stream.next();
+    return ERRORCLASS;
+  }
+  function tokenStringFactory(delimiter) {
+    var singleline = delimiter.length == 1;
+    var OUTCLASS = "string";
+    return function(stream, state) {
+      while (!stream.eol()) {
+        stream.eatWhile(/[^'"]/);
+        if (stream.match(delimiter)) {
+          state.tokenize = tokenBase;
+          return OUTCLASS;
+        } else {
+          stream.eat(/['"]/);
+        }
+      }
+      if (singleline) {
+        state.tokenize = tokenBase;
+      }
+      return OUTCLASS;
+    };
+  }
+  function tokenLexer(stream, state) {
+    var style = state.tokenize(stream, state);
+    var current = stream.current();
+    if (current === ".") {
+      style = state.tokenize(stream, state);
+      current = stream.current();
+      if (style && (style.substr(0, 8) === "variable" || style === "builtin" || style === "keyword")) {
+        if (style === "builtin" || style === "keyword") style = "variable";
+        if (knownWords.indexOf(current.substr(1)) > -1) style = "keyword";
+        return style;
+      } else {
+        return ERRORCLASS;
+      }
+    }
+    return style;
+  }
+  return {
+    name: "vbscript",
+    startState: function() {
+      return {
+        tokenize: tokenBase,
+        lastToken: null,
+        currentIndent: 0,
+        nextLineIndent: 0,
+        doInCurrentLine: false,
+        ignoreKeyword: false
+      };
+    },
+    token: function(stream, state) {
+      if (stream.sol()) {
+        state.currentIndent += state.nextLineIndent;
+        state.nextLineIndent = 0;
+        state.doInCurrentLine = 0;
+      }
+      var style = tokenLexer(stream, state);
+      state.lastToken = { style, content: stream.current() };
+      if (style === null) style = null;
+      return style;
+    },
+    indent: function(state, textAfter, cx) {
+      var trueText = textAfter.replace(/^\s+|\s+$/g, "");
+      if (trueText.match(closing) || trueText.match(doubleClosing) || trueText.match(middle)) return cx.unit * (state.currentIndent - 1);
+      if (state.currentIndent < 0) return 0;
+      return state.currentIndent * cx.unit;
+    }
+  };
+}
+const vbScript = mkVBScript({});
+mkVBScript({ isASP: true });
+export {
+  vbScript
+};

package/dist-ssg/server/assets/velocity-BwIZK1TH.js

@@ -0,0 +1,149 @@
+function parseWords(str) {
+  var obj = {}, words = str.split(" ");
+  for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+  return obj;
+}
+var keywords = parseWords("#end #else #break #stop #[[ #]] #{end} #{else} #{break} #{stop}");
+var functions = parseWords("#if #elseif #foreach #set #include #parse #macro #define #evaluate #{if} #{elseif} #{foreach} #{set} #{include} #{parse} #{macro} #{define} #{evaluate}");
+var specials = parseWords("$foreach.count $foreach.hasNext $foreach.first $foreach.last $foreach.topmost $foreach.parent.count $foreach.parent.hasNext $foreach.parent.first $foreach.parent.last $foreach.parent $velocityCount $!bodyContent $bodyContent");
+var isOperatorChar = /[+\-*&%=<>!?:\/|]/;
+function chain(stream, state, f) {
+  state.tokenize = f;
+  return f(stream, state);
+}
+function tokenBase(stream, state) {
+  var beforeParams = state.beforeParams;
+  state.beforeParams = false;
+  var ch = stream.next();
+  if (ch == "'" && !state.inString && state.inParams) {
+    state.lastTokenWasBuiltin = false;
+    return chain(stream, state, tokenString(ch));
+  } else if (ch == '"') {
+    state.lastTokenWasBuiltin = false;
+    if (state.inString) {
+      state.inString = false;
+      return "string";
+    } else if (state.inParams)
+      return chain(stream, state, tokenString(ch));
+  } else if (/[\[\]{}\(\),;\.]/.test(ch)) {
+    if (ch == "(" && beforeParams)
+      state.inParams = true;
+    else if (ch == ")") {
+      state.inParams = false;
+      state.lastTokenWasBuiltin = true;
+    }
+    return null;
+  } else if (/\d/.test(ch)) {
+    state.lastTokenWasBuiltin = false;
+    stream.eatWhile(/[\w\.]/);
+    return "number";
+  } else if (ch == "#" && stream.eat("*")) {
+    state.lastTokenWasBuiltin = false;
+    return chain(stream, state, tokenComment);
+  } else if (ch == "#" && stream.match(/ *\[ *\[/)) {
+    state.lastTokenWasBuiltin = false;
+    return chain(stream, state, tokenUnparsed);
+  } else if (ch == "#" && stream.eat("#")) {
+    state.lastTokenWasBuiltin = false;
+    stream.skipToEnd();
+    return "comment";
+  } else if (ch == "$") {
+    stream.eat("!");
+    stream.eatWhile(/[\w\d\$_\.{}-]/);
+    if (specials && specials.propertyIsEnumerable(stream.current())) {
+      return "keyword";
+    } else {
+      state.lastTokenWasBuiltin = true;
+      state.beforeParams = true;
+      return "builtin";
+    }
+  } else if (isOperatorChar.test(ch)) {
+    state.lastTokenWasBuiltin = false;
+    stream.eatWhile(isOperatorChar);
+    return "operator";
+  } else {
+    stream.eatWhile(/[\w\$_{}@]/);
+    var word = stream.current();
+    if (keywords && keywords.propertyIsEnumerable(word))
+      return "keyword";
+    if (functions && functions.propertyIsEnumerable(word) || stream.current().match(/^#@?[a-z0-9_]+ *$/i) && stream.peek() == "(" && !(functions && functions.propertyIsEnumerable(word.toLowerCase()))) {
+      state.beforeParams = true;
+      state.lastTokenWasBuiltin = false;
+      return "keyword";
+    }
+    if (state.inString) {
+      state.lastTokenWasBuiltin = false;
+      return "string";
+    }
+    if (stream.pos > word.length && stream.string.charAt(stream.pos - word.length - 1) == "." && state.lastTokenWasBuiltin)
+      return "builtin";
+    state.lastTokenWasBuiltin = false;
+    return null;
+  }
+}
+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;
+      }
+      if (quote == '"' && stream.peek() == "$" && !escaped) {
+        state.inString = true;
+        end = true;
+        break;
+      }
+      escaped = !escaped && next == "\\";
+    }
+    if (end) state.tokenize = tokenBase;
+    return "string";
+  };
+}
+function tokenComment(stream, state) {
+  var maybeEnd = false, ch;
+  while (ch = stream.next()) {
+    if (ch == "#" && maybeEnd) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    maybeEnd = ch == "*";
+  }
+  return "comment";
+}
+function tokenUnparsed(stream, state) {
+  var maybeEnd = 0, ch;
+  while (ch = stream.next()) {
+    if (ch == "#" && maybeEnd == 2) {
+      state.tokenize = tokenBase;
+      break;
+    }
+    if (ch == "]")
+      maybeEnd++;
+    else if (ch != " ")
+      maybeEnd = 0;
+  }
+  return "meta";
+}
+const velocity = {
+  name: "velocity",
+  startState: function() {
+    return {
+      tokenize: tokenBase,
+      beforeParams: false,
+      inParams: false,
+      inString: false,
+      lastTokenWasBuiltin: false
+    };
+  },
+  token: function(stream, state) {
+    if (stream.eatSpace()) return null;
+    return state.tokenize(stream, state);
+  },
+  languageData: {
+    commentTokens: { line: "##", block: { open: "#*", close: "*#" } }
+  }
+};
+export {
+  velocity
+};

package/dist-ssg/server/assets/verilog-CCb_iTfF.js

@@ -0,0 +1,7 @@
+const lang = Object.freeze(JSON.parse('{"displayName":"Verilog","fileTypes":["v","vh"],"name":"verilog","patterns":[{"include":"#comments"},{"include":"#module_pattern"},{"include":"#keywords"},{"include":"#constants"},{"include":"#strings"},{"include":"#operators"}],"repository":{"comments":{"patterns":[{"begin":"(^[\\\\t ]+)?(?=//)","beginCaptures":{"1":{"name":"punctuation.whitespace.comment.leading.verilog"}},"end":"(?!\\\\G)","patterns":[{"begin":"//","beginCaptures":{"0":{"name":"punctuation.definition.comment.verilog"}},"end":"\\\\n","name":"comment.line.double-slash.verilog"}]},{"begin":"/\\\\*","end":"\\\\*/","name":"comment.block.c-style.verilog"}]},"constants":{"patterns":[{"match":"`(?!(celldefine|endcelldefine|default_nettype|define|undef|ifdef|ifndef|else|endif|include|resetall|timescale|unconnected_drive|nounconnected_drive))[A-Z_a-z][$0-9A-Z_a-z]*","name":"variable.other.constant.verilog"},{"match":"[0-9]*\'[BDHObdho][XZ_xz\\\\h]+\\\\b","name":"constant.numeric.sized_integer.verilog"},{"captures":{"1":{"name":"constant.numeric.integer.verilog"},"2":{"name":"punctuation.separator.range.verilog"},"3":{"name":"constant.numeric.integer.verilog"}},"match":"\\\\b(\\\\d+)(:)(\\\\d+)\\\\b","name":"meta.block.numeric.range.verilog"},{"match":"\\\\b\\\\d[_\\\\d]*(?i:e\\\\d+)?\\\\b","name":"constant.numeric.integer.verilog"},{"match":"\\\\b\\\\d+\\\\.\\\\d+(?i:e\\\\d+)?\\\\b","name":"constant.numeric.real.verilog"},{"match":"#\\\\d+","name":"constant.numeric.delay.verilog"},{"match":"\\\\b[01XZxz]+\\\\b","name":"constant.numeric.logic.verilog"}]},"instantiation_patterns":{"patterns":[{"include":"#keywords"},{"begin":"^\\\\s*(?!always|and|assign|output|input|inout|wire|module)([A-Za-z][0-9A-Z_a-z]*)\\\\s+([A-Za-z][0-9A-Z_a-z]*)(?<!begin|if)\\\\s*(?=\\\\(|$)","beginCaptures":{"1":{"name":"entity.name.tag.module.reference.verilog"},"2":{"name":"entity.name.tag.module.identifier.verilog"}},"end":";","endCaptures":{"0":{"name":"punctuation.terminator.expression.verilog"}},"name":"meta.block.instantiation.parameterless.verilog","patterns":[{"include":"#comments"},{"include":"#constants"},{"include":"#strings"}]},{"begin":"^\\\\s*([A-Za-z][0-9A-Z_a-z]*)\\\\s*(#)(?=\\\\s*\\\\()","beginCaptures":{"1":{"name":"entity.name.tag.module.reference.verilog"}},"end":";","endCaptures":{"0":{"name":"punctuation.terminator.expression.verilog"}},"name":"meta.block.instantiation.with.parameters.verilog","patterns":[{"include":"#parenthetical_list"},{"match":"[A-Za-z][0-9A-Z_a-z]*","name":"entity.name.tag.module.identifier.verilog"}]}]},"keywords":{"patterns":[{"match":"\\\\b(always|and|assign|attribute|begin|buf|bufif0|bufif1|case[xz]?|cmos|deassign|default|defparam|disable|edge|else|end(attribute|case|function|generate|module|primitive|specify|table|task)?|event|for|force|forever|fork|function|generate|genvar|highz(01)|if(none)?|initial|inout|input|integer|join|localparam|medium|module|large|macromodule|nand|negedge|nmos|nor|not|notif(01)|or|output|parameter|pmos|posedge|primitive|pull0|pull1|pulldown|pullup|rcmos|real|realtime|reg|release|repeat|rnmos|rpmos|rtran|rtranif(01)|scalared|signed|small|specify|specparam|strength|strong0|strong1|supply0|supply1|table|task|time|tran|tranif(01)|tri(01)?|tri(and|or|reg)|unsigned|vectored|wait|wand|weak(01)|while|wire|wor|xnor|xor)\\\\b","name":"keyword.other.verilog"},{"match":"^\\\\s*`((cell)?define|default_(decay_time|nettype|trireg_strength)|delay_mode_(path|unit|zero)|ifdef|ifndef|include|end(if|celldefine)|else|(no)?unconnected_drive|resetall|timescale|undef)\\\\b","name":"keyword.other.compiler.directive.verilog"},{"match":"\\\\$(f(open|close)|readmem([bh])|timeformat|printtimescale|stop|finish|(s|real)?time|realtobits|bitstoreal|rtoi|itor|(f)?(display|write([bh])))\\\\b","name":"support.function.system.console.tasks.verilog"},{"match":"\\\\$(random|dist_(chi_square|erlang|exponential|normal|poisson|t|uniform))\\\\b","name":"support.function.system.random_number.tasks.verilog"},{"match":"\\\\$((a)?sync\\\\$((n)?and|(n)or)\\\\$(array|plane))\\\\b","name":"support.function.system.pld_modeling.tasks.verilog"},{"match":"\\\\$(q_(initialize|add|remove|full|exam))\\\\b","name":"support.function.system.stochastic.tasks.verilog"},{"match":"\\\\$(hold|nochange|period|recovery|setup(hold)?|skew|width)\\\\b","name":"support.function.system.timing.tasks.verilog"},{"match":"\\\\$(dump(file|vars|off|on|all|limit|flush))\\\\b","name":"support.function.system.vcd.tasks.verilog"},{"match":"\\\\$(countdrivers|list|input|scope|showscopes|(no)?(key|log)|reset(_(?:count|value))?|(inc)?save|restart|showvars|getpattern|sreadmem([bh])|scale)","name":"support.function.non-standard.tasks.verilog"}]},"module_pattern":{"patterns":[{"begin":"\\\\b(module)\\\\s+([A-Za-z][0-9A-Z_a-z]*)","beginCaptures":{"1":{"name":"storage.type.module.verilog"},"2":{"name":"entity.name.type.module.verilog"}},"end":"\\\\bendmodule\\\\b","endCaptures":{"0":{"name":"storage.type.module.verilog"}},"name":"meta.block.module.verilog","patterns":[{"include":"#comments"},{"include":"#keywords"},{"include":"#constants"},{"include":"#strings"},{"include":"#instantiation_patterns"},{"include":"#operators"}]}]},"operators":{"patterns":[{"match":"[-%*+/]|([<>])=?|([!=])?==?|!|&&?|\\\\|\\\\|?|\\\\^?~|~\\\\^?","name":"keyword.operator.verilog"}]},"parenthetical_list":{"patterns":[{"begin":"\\\\(","beginCaptures":{"0":{"name":"punctuation.section.list.verilog"}},"end":"\\\\)","endCaptures":{"0":{"name":"punctuation.section.list.verilog"}},"name":"meta.block.parenthetical_list.verilog","patterns":[{"include":"#parenthetical_list"},{"include":"#comments"},{"include":"#keywords"},{"include":"#constants"},{"include":"#strings"}]}]},"strings":{"patterns":[{"begin":"\\"","end":"\\"","name":"string.quoted.double.verilog","patterns":[{"match":"\\\\\\\\.","name":"constant.character.escape.verilog"}]}]}},"scopeName":"source.verilog"}'));
+const verilog = [
+  lang
+];
+export {
+  verilog as default
+};