@vc-shell/framework 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [1.1.2](https://github.com/VirtoCommerce/vc-shell/compare/v1.1.1...v1.1.2) (2025-04-29)
+
+
+
+## [1.1.1](https://github.com/VirtoCommerce/vc-shell/compare/v1.1.0...v1.1.1) (2025-04-29)
+
+
+
 # [1.1.0](https://github.com/VirtoCommerce/vc-shell/compare/v1.1.0-alpha.2...v1.1.0) (2025-04-29)
 
 

package/dist/assets/apl-NdZ6-T1z.js

@@ -0,0 +1,142 @@
+var builtInFuncs = {
+  "+": ["conjugate", "add"],
+  "−": ["negate", "subtract"],
+  "×": ["signOf", "multiply"],
+  "÷": ["reciprocal", "divide"],
+  "⌈": ["ceiling", "greaterOf"],
+  "⌊": ["floor", "lesserOf"],
+  "∣": ["absolute", "residue"],
+  "⍳": ["indexGenerate", "indexOf"],
+  "?": ["roll", "deal"],
+  "⋆": ["exponentiate", "toThePowerOf"],
+  "⍟": ["naturalLog", "logToTheBase"],
+  "○": ["piTimes", "circularFuncs"],
+  "!": ["factorial", "binomial"],
+  "⌹": ["matrixInverse", "matrixDivide"],
+  "<": [null, "lessThan"],
+  "≤": [null, "lessThanOrEqual"],
+  "=": [null, "equals"],
+  ">": [null, "greaterThan"],
+  "≥": [null, "greaterThanOrEqual"],
+  "≠": [null, "notEqual"],
+  "≡": ["depth", "match"],
+  "≢": [null, "notMatch"],
+  "∈": ["enlist", "membership"],
+  "⍷": [null, "find"],
+  "∪": ["unique", "union"],
+  "∩": [null, "intersection"],
+  "∼": ["not", "without"],
+  "∨": [null, "or"],
+  "∧": [null, "and"],
+  "⍱": [null, "nor"],
+  "⍲": [null, "nand"],
+  "⍴": ["shapeOf", "reshape"],
+  ",": ["ravel", "catenate"],
+  "⍪": [null, "firstAxisCatenate"],
+  "⌽": ["reverse", "rotate"],
+  "⊖": ["axis1Reverse", "axis1Rotate"],
+  "⍉": ["transpose", null],
+  "↑": ["first", "take"],
+  "↓": [null, "drop"],
+  "⊂": ["enclose", "partitionWithAxis"],
+  "⊃": ["diclose", "pick"],
+  "⌷": [null, "index"],
+  "⍋": ["gradeUp", null],
+  "⍒": ["gradeDown", null],
+  "⊤": ["encode", null],
+  "⊥": ["decode", null],
+  "⍕": ["format", "formatByExample"],
+  "⍎": ["execute", null],
+  "⊣": ["stop", "left"],
+  "⊢": ["pass", "right"]
+};
+
+var isOperator = /[\.\/⌿⍀¨⍣]/;
+var isNiladic = /⍬/;
+var isFunction = /[\+−×÷⌈⌊∣⍳\?⋆⍟○!⌹<≤=>≥≠≡≢∈⍷∪∩∼∨∧⍱⍲⍴,⍪⌽⊖⍉↑↓⊂⊃⌷⍋⍒⊤⊥⍕⍎⊣⊢]/;
+var isArrow = /←/;
+var isComment = /[⍝#].*$/;
+
+var stringEater = function(type) {
+  var prev;
+  prev = false;
+  return function(c) {
+    prev = c;
+    if (c === type) {
+      return prev === "\\";
+    }
+    return true;
+  };
+};
+
+const apl = {
+  name: "apl",
+  startState: function() {
+    return {
+      prev: false,
+      func: false,
+      op: false,
+      string: false,
+      escape: false
+    };
+  },
+  token: function(stream, state) {
+    var ch;
+    if (stream.eatSpace()) {
+      return null;
+    }
+    ch = stream.next();
+    if (ch === '"' || ch === "'") {
+      stream.eatWhile(stringEater(ch));
+      stream.next();
+      state.prev = true;
+      return "string";
+    }
+    if (/[\[{\(]/.test(ch)) {
+      state.prev = false;
+      return null;
+    }
+    if (/[\]}\)]/.test(ch)) {
+      state.prev = true;
+      return null;
+    }
+    if (isNiladic.test(ch)) {
+      state.prev = false;
+      return "atom";
+    }
+    if (/[¯\d]/.test(ch)) {
+      if (state.func) {
+        state.func = false;
+        state.prev = false;
+      } else {
+        state.prev = true;
+      }
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (isOperator.test(ch)) {
+      return "operator"
+    }
+    if (isArrow.test(ch)) {
+      return "operator";
+    }
+    if (isFunction.test(ch)) {
+      state.func = true;
+      state.prev = false;
+      return builtInFuncs[ch] ? "variableName.function.standard" : "variableName.function"
+    }
+    if (isComment.test(ch)) {
+      stream.skipToEnd();
+      return "comment";
+    }
+    if (ch === "∘" && stream.peek() === ".") {
+      stream.next();
+      return "variableName.function";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    state.prev = true;
+    return "keyword";
+  }
+};
+
+export { apl };

package/dist/assets/asciiarmor-CmJEbAuq.js

@@ -0,0 +1,56 @@
+function errorIfNotEmpty(stream) {
+  var nonWS = stream.match(/^\s*\S/);
+  stream.skipToEnd();
+  return nonWS ? "error" : null;
+}
+
+const asciiArmor = {
+  name: "asciiarmor",
+  token: function(stream, state) {
+    var m;
+    if (state.state == "top") {
+      if (stream.sol() && (m = stream.match(/^-----BEGIN (.*)?-----\s*$/))) {
+        state.state = "headers";
+        state.type = m[1];
+        return "tag";
+      }
+      return errorIfNotEmpty(stream);
+    } else if (state.state == "headers") {
+      if (stream.sol() && stream.match(/^\w+:/)) {
+        state.state = "header";
+        return "atom";
+      } else {
+        var result = errorIfNotEmpty(stream);
+        if (result) state.state = "body";
+        return result;
+      }
+    } else if (state.state == "header") {
+      stream.skipToEnd();
+      state.state = "headers";
+      return "string";
+    } else if (state.state == "body") {
+      if (stream.sol() && (m = stream.match(/^-----END (.*)?-----\s*$/))) {
+        if (m[1] != state.type) return "error";
+        state.state = "end";
+        return "tag";
+      } else {
+        if (stream.eatWhile(/[A-Za-z0-9+\/=]/)) {
+          return null;
+        } else {
+          stream.next();
+          return "error";
+        }
+      }
+    } else if (state.state == "end") {
+      return errorIfNotEmpty(stream);
+    }
+  },
+  blankLine: function(state) {
+    if (state.state == "headers") state.state = "body";
+  },
+  startState: function() {
+    return {state: "top", type: null};
+  }
+};
+
+export { asciiArmor };

package/dist/assets/asn1-Ctc8K72v.js

@@ -0,0 +1,192 @@
+function words(str) {
+  var obj = {}, words = str.split(" ");
+  for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+  return obj;
+}
+
+const defaults = {
+  keywords: words("DEFINITIONS OBJECTS IF DERIVED INFORMATION ACTION" +
+                  " REPLY ANY NAMED CHARACTERIZED BEHAVIOUR REGISTERED" +
+                  " WITH AS IDENTIFIED CONSTRAINED BY PRESENT BEGIN" +
+                  " IMPORTS FROM UNITS SYNTAX MIN-ACCESS MAX-ACCESS" +
+                  " MINACCESS MAXACCESS REVISION STATUS DESCRIPTION" +
+                  " SEQUENCE SET COMPONENTS OF CHOICE DistinguishedName" +
+                  " ENUMERATED SIZE MODULE END INDEX AUGMENTS EXTENSIBILITY" +
+                  " IMPLIED EXPORTS"),
+  cmipVerbs: words("ACTIONS ADD GET NOTIFICATIONS REPLACE REMOVE"),
+  compareTypes: words("OPTIONAL DEFAULT MANAGED MODULE-TYPE MODULE_IDENTITY" +
+                      " MODULE-COMPLIANCE OBJECT-TYPE OBJECT-IDENTITY" +
+                      " OBJECT-COMPLIANCE MODE CONFIRMED CONDITIONAL" +
+                      " SUBORDINATE SUPERIOR CLASS TRUE FALSE NULL" +
+                      " TEXTUAL-CONVENTION"),
+  status: words("current deprecated mandatory obsolete"),
+  tags: words("APPLICATION AUTOMATIC EXPLICIT IMPLICIT PRIVATE TAGS" +
+              " UNIVERSAL"),
+  storage: words("BOOLEAN INTEGER OBJECT IDENTIFIER BIT OCTET STRING" +
+                 " UTCTime InterfaceIndex IANAifType CMIP-Attribute" +
+                 " REAL PACKAGE PACKAGES IpAddress PhysAddress" +
+                 " NetworkAddress BITS BMPString TimeStamp TimeTicks" +
+                 " TruthValue RowStatus DisplayString GeneralString" +
+                 " GraphicString IA5String NumericString" +
+                 " PrintableString SnmpAdminString TeletexString" +
+                 " UTF8String VideotexString VisibleString StringStore" +
+                 " ISO646String T61String UniversalString Unsigned32" +
+                 " Integer32 Gauge Gauge32 Counter Counter32 Counter64"),
+  modifier: words("ATTRIBUTE ATTRIBUTES MANDATORY-GROUP MANDATORY-GROUPS" +
+                  " GROUP GROUPS ELEMENTS EQUALITY ORDERING SUBSTRINGS" +
+                  " DEFINED"),
+  accessTypes: words("not-accessible accessible-for-notify read-only" +
+                     " read-create read-write"),
+  multiLineStrings: true
+};
+
+function asn1(parserConfig) {
+  var keywords = parserConfig.keywords || defaults.keywords,
+      cmipVerbs = parserConfig.cmipVerbs || defaults.cmipVerbs,
+      compareTypes = parserConfig.compareTypes || defaults.compareTypes,
+      status = parserConfig.status || defaults.status,
+      tags = parserConfig.tags || defaults.tags,
+      storage = parserConfig.storage || defaults.storage,
+      modifier = parserConfig.modifier || defaults.modifier,
+      accessTypes = parserConfig.accessTypes|| defaults.accessTypes;
+      parserConfig.multiLineStrings || defaults.multiLineStrings;
+      var indentStatements = parserConfig.indentStatements !== false;
+  var isOperatorChar = /[\|\^]/;
+  var curPunc;
+
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    if (ch == '"' || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (/[\[\]\(\){}:=,;]/.test(ch)) {
+      curPunc = ch;
+      return "punctuation";
+    }
+    if (ch == "-"){
+      if (stream.eat("-")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+    }
+    if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+
+    stream.eatWhile(/[\w\-]/);
+    var cur = stream.current();
+    if (keywords.propertyIsEnumerable(cur)) return "keyword";
+    if (cmipVerbs.propertyIsEnumerable(cur)) return "variableName";
+    if (compareTypes.propertyIsEnumerable(cur)) return "atom";
+    if (status.propertyIsEnumerable(cur)) return "comment";
+    if (tags.propertyIsEnumerable(cur)) return "typeName";
+    if (storage.propertyIsEnumerable(cur)) return "modifier";
+    if (modifier.propertyIsEnumerable(cur)) return "modifier";
+    if (accessTypes.propertyIsEnumerable(cur)) return "modifier";
+
+    return "variableName";
+  }
+
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped){
+          var afterNext = stream.peek();
+          //look if the character if the quote is like the B in '10100010'B
+          if (afterNext){
+            afterNext = afterNext.toLowerCase();
+            if(afterNext == "b" || afterNext == "h" || afterNext == "o")
+              stream.next();
+          }
+          end = true; break;
+        }
+        escaped = !escaped && next == "\\";
+      }
+      if (end || false)
+        state.tokenize = null;
+      return "string";
+    };
+  }
+
+  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;
+  }
+
+  //Interface
+  return {
+    name: "asn1",
+    startState: function() {
+      return {
+        tokenize: null,
+        context: new Context(-2, 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") 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 (indentStatements && (((ctx.type == "}" || ctx.type == "top")
+                                     && curPunc != ';') || (ctx.type == "statement"
+                                                            && curPunc == "newstatement")))
+        pushContext(state, stream.column(), "statement");
+
+      state.startOfLine = false;
+      return style;
+    },
+
+    languageData: {
+      indentOnInput: /^\s*[{}]$/,
+      commentTokens: {line: "--"}
+    }
+  };
+}
+
+export { asn1 };

package/dist/assets/asterisk-D6r__RMF.js

@@ -0,0 +1,187 @@
+var atoms    = ["exten", "same", "include","ignorepat","switch"],
+    dpcmd    = ["#include","#exec"],
+    apps     = [
+      "addqueuemember","adsiprog","aelsub","agentlogin","agentmonitoroutgoing","agi",
+      "alarmreceiver","amd","answer","authenticate","background","backgrounddetect",
+      "bridge","busy","callcompletioncancel","callcompletionrequest","celgenuserevent",
+      "changemonitor","chanisavail","channelredirect","chanspy","clearhash","confbridge",
+      "congestion","continuewhile","controlplayback","dahdiacceptr2call","dahdibarge",
+      "dahdiras","dahdiscan","dahdisendcallreroutingfacility","dahdisendkeypadfacility",
+      "datetime","dbdel","dbdeltree","deadagi","dial","dictate","directory","disa",
+      "dumpchan","eagi","echo","endwhile","exec","execif","execiftime","exitwhile","extenspy",
+      "externalivr","festival","flash","followme","forkcdr","getcpeid","gosub","gosubif",
+      "goto","gotoif","gotoiftime","hangup","iax2provision","ices","importvar","incomplete",
+      "ivrdemo","jabberjoin","jabberleave","jabbersend","jabbersendgroup","jabberstatus",
+      "jack","log","macro","macroexclusive","macroexit","macroif","mailboxexists","meetme",
+      "meetmeadmin","meetmechanneladmin","meetmecount","milliwatt","minivmaccmess","minivmdelete",
+      "minivmgreet","minivmmwi","minivmnotify","minivmrecord","mixmonitor","monitor","morsecode",
+      "mp3player","mset","musiconhold","nbscat","nocdr","noop","odbc","odbc","odbcfinish",
+      "originate","ospauth","ospfinish","osplookup","ospnext","page","park","parkandannounce",
+      "parkedcall","pausemonitor","pausequeuemember","pickup","pickupchan","playback","playtones",
+      "privacymanager","proceeding","progress","queue","queuelog","raiseexception","read","readexten",
+      "readfile","receivefax","receivefax","receivefax","record","removequeuemember",
+      "resetcdr","retrydial","return","ringing","sayalpha","saycountedadj","saycountednoun",
+      "saycountpl","saydigits","saynumber","sayphonetic","sayunixtime","senddtmf","sendfax",
+      "sendfax","sendfax","sendimage","sendtext","sendurl","set","setamaflags",
+      "setcallerpres","setmusiconhold","sipaddheader","sipdtmfmode","sipremoveheader","skel",
+      "slastation","slatrunk","sms","softhangup","speechactivategrammar","speechbackground",
+      "speechcreate","speechdeactivategrammar","speechdestroy","speechloadgrammar","speechprocessingsound",
+      "speechstart","speechunloadgrammar","stackpop","startmusiconhold","stopmixmonitor","stopmonitor",
+      "stopmusiconhold","stopplaytones","system","testclient","testserver","transfer","tryexec",
+      "trysystem","unpausemonitor","unpausequeuemember","userevent","verbose","vmauthenticate",
+      "vmsayname","voicemail","voicemailmain","wait","waitexten","waitfornoise","waitforring",
+      "waitforsilence","waitmusiconhold","waituntil","while","zapateller"
+    ];
+
+function basicToken(stream,state){
+  var cur = '';
+  var ch = stream.next();
+  // comment
+  if (state.blockComment) {
+    if (ch == "-" && stream.match("-;", true)) {
+      state.blockComment = false;
+    } else if (stream.skipTo("--;")) {
+      stream.next();
+      stream.next();
+      stream.next();
+      state.blockComment = false;
+    } else {
+      stream.skipToEnd();
+    }
+    return "comment";
+  }
+  if(ch == ";") {
+    if (stream.match("--", true)) {
+      if (!stream.match("-", false)) {  // Except ;--- is not a block comment
+        state.blockComment = true;
+        return "comment";
+      }
+    }
+    stream.skipToEnd();
+    return "comment";
+  }
+  // context
+  if(ch == '[') {
+    stream.skipTo(']');
+    stream.eat(']');
+    return "header";
+  }
+  // string
+  if(ch == '"') {
+    stream.skipTo('"');
+    return "string";
+  }
+  if(ch == "'") {
+    stream.skipTo("'");
+    return "string.special";
+  }
+  // dialplan commands
+  if(ch == '#') {
+    stream.eatWhile(/\w/);
+    cur = stream.current();
+    if(dpcmd.indexOf(cur) !== -1) {
+      stream.skipToEnd();
+      return "strong";
+    }
+  }
+  // application args
+  if(ch == '$'){
+    var ch1 = stream.peek();
+    if(ch1 == '{'){
+      stream.skipTo('}');
+      stream.eat('}');
+      return "variableName.special";
+    }
+  }
+  // extension
+  stream.eatWhile(/\w/);
+  cur = stream.current();
+  if(atoms.indexOf(cur) !== -1) {
+    state.extenStart = true;
+    switch(cur) {
+    case 'same': state.extenSame = true; break;
+    case 'include':
+    case 'switch':
+    case 'ignorepat':
+      state.extenInclude = true;break;
+    }
+    return "atom";
+  }
+}
+
+const asterisk = {
+  name: "asterisk",
+  startState: function() {
+    return {
+      blockComment: false,
+      extenStart: false,
+      extenSame:  false,
+      extenInclude: false,
+      extenExten: false,
+      extenPriority: false,
+      extenApplication: false
+    };
+  },
+  token: function(stream, state) {
+
+    var cur = '';
+    if(stream.eatSpace()) return null;
+    // extension started
+    if(state.extenStart){
+      stream.eatWhile(/[^\s]/);
+      cur = stream.current();
+      if(/^=>?$/.test(cur)){
+        state.extenExten = true;
+        state.extenStart = false;
+        return "strong";
+      } else {
+        state.extenStart = false;
+        stream.skipToEnd();
+        return "error";
+      }
+    } else if(state.extenExten) {
+      // set exten and priority
+      state.extenExten = false;
+      state.extenPriority = true;
+      stream.eatWhile(/[^,]/);
+      if(state.extenInclude) {
+        stream.skipToEnd();
+        state.extenPriority = false;
+        state.extenInclude = false;
+      }
+      if(state.extenSame) {
+        state.extenPriority = false;
+        state.extenSame = false;
+        state.extenApplication = true;
+      }
+      return "tag";
+    } else if(state.extenPriority) {
+      state.extenPriority = false;
+      state.extenApplication = true;
+      stream.next(); // get comma
+      if(state.extenSame) return null;
+      stream.eatWhile(/[^,]/);
+      return "number";
+    } else if(state.extenApplication) {
+      stream.eatWhile(/,/);
+      cur = stream.current();
+      if(cur === ',') return null;
+      stream.eatWhile(/\w/);
+      cur = stream.current().toLowerCase();
+      state.extenApplication = false;
+      if(apps.indexOf(cur) !== -1){
+        return "def";
+      }
+    } else {
+      return basicToken(stream,state);
+    }
+
+    return null;
+  },
+
+  languageData: {
+    commentTokens: {line: ";", block: {open: ";--", close: "--;"}}
+  }
+};
+
+export { asterisk };

package/dist/assets/brainfuck-COwWCBpq.js

@@ -0,0 +1,70 @@
+var reserve = "><+-.,[]".split("");
+/*
+  comments can be either:
+  placed behind lines
+
+  +++    this is a comment
+
+  where reserved characters cannot be used
+  or in a loop
+  [
+  this is ok to use [ ] and stuff
+  ]
+  or preceded by #
+*/
+const brainfuck = {
+  name: "brainfuck",
+  startState: function() {
+    return {
+      commentLine: false,
+      left: 0,
+      right: 0,
+      commentLoop: false
+    }
+  },
+  token: function(stream, state) {
+    if (stream.eatSpace()) return null
+    if(stream.sol()){
+      state.commentLine = false;
+    }
+    var ch = stream.next().toString();
+    if(reserve.indexOf(ch) !== -1){
+      if(state.commentLine === true){
+        if(stream.eol()){
+          state.commentLine = false;
+        }
+        return "comment";
+      }
+      if(ch === "]" || ch === "["){
+        if(ch === "["){
+          state.left++;
+        }
+        else {
+          state.right++;
+        }
+        return "bracket";
+      }
+      else if(ch === "+" || ch === "-"){
+        return "keyword";
+      }
+      else if(ch === "<" || ch === ">"){
+        return "atom";
+      }
+      else if(ch === "." || ch === ","){
+        return "def";
+      }
+    }
+    else {
+      state.commentLine = true;
+      if(stream.eol()){
+        state.commentLine = false;
+      }
+      return "comment";
+    }
+    if(stream.eol()){
+      state.commentLine = false;
+    }
+  }
+};
+
+export { brainfuck };