@glodon-aiot/agent-cli-ui 3.19.0-alpha.30 → 3.19.0-beta.31

package/dist/es/node_modules/refractor/lang/mongodb.mjs

@@ -1,287 +0,0 @@
-var a, r;
-function l() {
-  if (r)
-    return a;
-  r = 1, a = $, $.displayName = "mongodb", $.aliases = [];
-  function $(n) {
-    (function(e) {
-      var t = [
-        // query and projection
-        "$eq",
-        "$gt",
-        "$gte",
-        "$in",
-        "$lt",
-        "$lte",
-        "$ne",
-        "$nin",
-        "$and",
-        "$not",
-        "$nor",
-        "$or",
-        "$exists",
-        "$type",
-        "$expr",
-        "$jsonSchema",
-        "$mod",
-        "$regex",
-        "$text",
-        "$where",
-        "$geoIntersects",
-        "$geoWithin",
-        "$near",
-        "$nearSphere",
-        "$all",
-        "$elemMatch",
-        "$size",
-        "$bitsAllClear",
-        "$bitsAllSet",
-        "$bitsAnyClear",
-        "$bitsAnySet",
-        "$comment",
-        "$elemMatch",
-        "$meta",
-        "$slice",
-        // update
-        "$currentDate",
-        "$inc",
-        "$min",
-        "$max",
-        "$mul",
-        "$rename",
-        "$set",
-        "$setOnInsert",
-        "$unset",
-        "$addToSet",
-        "$pop",
-        "$pull",
-        "$push",
-        "$pullAll",
-        "$each",
-        "$position",
-        "$slice",
-        "$sort",
-        "$bit",
-        // aggregation pipeline stages
-        "$addFields",
-        "$bucket",
-        "$bucketAuto",
-        "$collStats",
-        "$count",
-        "$currentOp",
-        "$facet",
-        "$geoNear",
-        "$graphLookup",
-        "$group",
-        "$indexStats",
-        "$limit",
-        "$listLocalSessions",
-        "$listSessions",
-        "$lookup",
-        "$match",
-        "$merge",
-        "$out",
-        "$planCacheStats",
-        "$project",
-        "$redact",
-        "$replaceRoot",
-        "$replaceWith",
-        "$sample",
-        "$set",
-        "$skip",
-        "$sort",
-        "$sortByCount",
-        "$unionWith",
-        "$unset",
-        "$unwind",
-        "$setWindowFields",
-        // aggregation pipeline operators
-        "$abs",
-        "$accumulator",
-        "$acos",
-        "$acosh",
-        "$add",
-        "$addToSet",
-        "$allElementsTrue",
-        "$and",
-        "$anyElementTrue",
-        "$arrayElemAt",
-        "$arrayToObject",
-        "$asin",
-        "$asinh",
-        "$atan",
-        "$atan2",
-        "$atanh",
-        "$avg",
-        "$binarySize",
-        "$bsonSize",
-        "$ceil",
-        "$cmp",
-        "$concat",
-        "$concatArrays",
-        "$cond",
-        "$convert",
-        "$cos",
-        "$dateFromParts",
-        "$dateToParts",
-        "$dateFromString",
-        "$dateToString",
-        "$dayOfMonth",
-        "$dayOfWeek",
-        "$dayOfYear",
-        "$degreesToRadians",
-        "$divide",
-        "$eq",
-        "$exp",
-        "$filter",
-        "$first",
-        "$floor",
-        "$function",
-        "$gt",
-        "$gte",
-        "$hour",
-        "$ifNull",
-        "$in",
-        "$indexOfArray",
-        "$indexOfBytes",
-        "$indexOfCP",
-        "$isArray",
-        "$isNumber",
-        "$isoDayOfWeek",
-        "$isoWeek",
-        "$isoWeekYear",
-        "$last",
-        "$last",
-        "$let",
-        "$literal",
-        "$ln",
-        "$log",
-        "$log10",
-        "$lt",
-        "$lte",
-        "$ltrim",
-        "$map",
-        "$max",
-        "$mergeObjects",
-        "$meta",
-        "$min",
-        "$millisecond",
-        "$minute",
-        "$mod",
-        "$month",
-        "$multiply",
-        "$ne",
-        "$not",
-        "$objectToArray",
-        "$or",
-        "$pow",
-        "$push",
-        "$radiansToDegrees",
-        "$range",
-        "$reduce",
-        "$regexFind",
-        "$regexFindAll",
-        "$regexMatch",
-        "$replaceOne",
-        "$replaceAll",
-        "$reverseArray",
-        "$round",
-        "$rtrim",
-        "$second",
-        "$setDifference",
-        "$setEquals",
-        "$setIntersection",
-        "$setIsSubset",
-        "$setUnion",
-        "$size",
-        "$sin",
-        "$slice",
-        "$split",
-        "$sqrt",
-        "$stdDevPop",
-        "$stdDevSamp",
-        "$strcasecmp",
-        "$strLenBytes",
-        "$strLenCP",
-        "$substr",
-        "$substrBytes",
-        "$substrCP",
-        "$subtract",
-        "$sum",
-        "$switch",
-        "$tan",
-        "$toBool",
-        "$toDate",
-        "$toDecimal",
-        "$toDouble",
-        "$toInt",
-        "$toLong",
-        "$toObjectId",
-        "$toString",
-        "$toLower",
-        "$toUpper",
-        "$trim",
-        "$trunc",
-        "$type",
-        "$week",
-        "$year",
-        "$zip",
-        "$count",
-        "$dateAdd",
-        "$dateDiff",
-        "$dateSubtract",
-        "$dateTrunc",
-        "$getField",
-        "$rand",
-        "$sampleRate",
-        "$setField",
-        "$unsetField",
-        // aggregation pipeline query modifiers
-        "$comment",
-        "$explain",
-        "$hint",
-        "$max",
-        "$maxTimeMS",
-        "$min",
-        "$orderby",
-        "$query",
-        "$returnKey",
-        "$showDiskLoc",
-        "$natural"
-      ], o = ["ObjectId", "Code", "BinData", "DBRef", "Timestamp", "NumberLong", "NumberDecimal", "MaxKey", "MinKey", "RegExp", "ISODate", "UUID"];
-      t = t.map(function(i) {
-        return i.replace("$", "\\$");
-      });
-      var s = "(?:" + t.join("|") + ")\\b";
-      e.languages.mongodb = e.languages.extend("javascript", {}), e.languages.insertBefore("mongodb", "string", {
-        property: {
-          pattern: /(?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)(?=\s*:)/,
-          greedy: !0,
-          inside: {
-            keyword: RegExp(`^(['"])?` + s + "(?:\\1)?$")
-          }
-        }
-      }), e.languages.mongodb.string.inside = {
-        url: {
-          // url pattern
-          pattern: /https?:\/\/[-\w@:%.+~#=]{1,256}\.[a-z0-9()]{1,6}\b[-\w()@:%+.~#?&/=]*/i,
-          greedy: !0
-        },
-        entity: {
-          // ipv4
-          pattern: /\b(?:(?:[01]?\d\d?|2[0-4]\d|25[0-5])\.){3}(?:[01]?\d\d?|2[0-4]\d|25[0-5])\b/,
-          greedy: !0
-        }
-      }, e.languages.insertBefore("mongodb", "constant", {
-        builtin: {
-          pattern: RegExp("\\b(?:" + o.join("|") + ")\\b"),
-          alias: "keyword"
-        }
-      });
-    })(n);
-  }
-  return a;
-}
-export {
-  l as __require
-};

package/dist/es/node_modules/refractor/lang/monkey.mjs

@@ -1,40 +0,0 @@
-var r, t;
-function o() {
-  if (t)
-    return r;
-  t = 1, r = e, e.displayName = "monkey", e.aliases = [];
-  function e(n) {
-    n.languages.monkey = {
-      comment: {
-        pattern: /^#Rem\s[\s\S]*?^#End|'.+/im,
-        greedy: !0
-      },
-      string: {
-        pattern: /"[^"\r\n]*"/,
-        greedy: !0
-      },
-      preprocessor: {
-        pattern: /(^[ \t]*)#.+/m,
-        lookbehind: !0,
-        greedy: !0,
-        alias: "property"
-      },
-      function: /\b\w+(?=\()/,
-      "type-char": {
-        pattern: /\b[?%#$]/,
-        alias: "class-name"
-      },
-      number: {
-        pattern: /((?:\.\.)?)(?:(?:\b|\B-\.?|\B\.)\d+(?:(?!\.\.)\.\d*)?|\$[\da-f]+)/i,
-        lookbehind: !0
-      },
-      keyword: /\b(?:Abstract|Array|Bool|Case|Catch|Class|Const|Continue|Default|Eachin|Else|ElseIf|End|EndIf|Exit|Extends|Extern|False|Field|Final|Float|For|Forever|Function|Global|If|Implements|Import|Inline|Int|Interface|Local|Method|Module|New|Next|Null|Object|Private|Property|Public|Repeat|Return|Select|Self|Step|Strict|String|Super|Then|Throw|To|True|Try|Until|Void|Wend|While)\b/i,
-      operator: /\.\.|<[=>]?|>=?|:?=|(?:[+\-*\/&~|]|\b(?:Mod|Shl|Shr)\b)=?|\b(?:And|Not|Or)\b/i,
-      punctuation: /[.,:;()\[\]]/
-    };
-  }
-  return r;
-}
-export {
-  o as __require
-};

package/dist/es/node_modules/refractor/lang/moonscript.mjs

@@ -1,63 +0,0 @@
-var n, a;
-function o() {
-  if (a)
-    return n;
-  a = 1, n = t, t.displayName = "moonscript", t.aliases = ["moon"];
-  function t(e) {
-    e.languages.moonscript = {
-      comment: /--.*/,
-      string: [{
-        pattern: /'[^']*'|\[(=*)\[[\s\S]*?\]\1\]/,
-        greedy: !0
-      }, {
-        pattern: /"[^"]*"/,
-        greedy: !0,
-        inside: {
-          interpolation: {
-            pattern: /#\{[^{}]*\}/,
-            inside: {
-              moonscript: {
-                pattern: /(^#\{)[\s\S]+(?=\})/,
-                lookbehind: !0,
-                inside: null
-                // see beow
-              },
-              "interpolation-punctuation": {
-                pattern: /#\{|\}/,
-                alias: "punctuation"
-              }
-            }
-          }
-        }
-      }],
-      "class-name": [
-        {
-          pattern: /(\b(?:class|extends)[ \t]+)\w+/,
-          lookbehind: !0
-        },
-        // class-like names start with a capital letter
-        /\b[A-Z]\w*/
-      ],
-      keyword: /\b(?:class|continue|do|else|elseif|export|extends|for|from|if|import|in|local|nil|return|self|super|switch|then|unless|using|when|while|with)\b/,
-      variable: /@@?\w*/,
-      property: {
-        pattern: /\b(?!\d)\w+(?=:)|(:)(?!\d)\w+/,
-        lookbehind: !0
-      },
-      function: {
-        pattern: /\b(?:_G|_VERSION|assert|collectgarbage|coroutine\.(?:create|resume|running|status|wrap|yield)|debug\.(?:debug|getfenv|gethook|getinfo|getlocal|getmetatable|getregistry|getupvalue|setfenv|sethook|setlocal|setmetatable|setupvalue|traceback)|dofile|error|getfenv|getmetatable|io\.(?:close|flush|input|lines|open|output|popen|read|stderr|stdin|stdout|tmpfile|type|write)|ipairs|load|loadfile|loadstring|math\.(?:abs|acos|asin|atan|atan2|ceil|cos|cosh|deg|exp|floor|fmod|frexp|ldexp|log|log10|max|min|modf|pi|pow|rad|random|randomseed|sin|sinh|sqrt|tan|tanh)|module|next|os\.(?:clock|date|difftime|execute|exit|getenv|remove|rename|setlocale|time|tmpname)|package\.(?:cpath|loaded|loadlib|path|preload|seeall)|pairs|pcall|print|rawequal|rawget|rawset|require|select|setfenv|setmetatable|string\.(?:byte|char|dump|find|format|gmatch|gsub|len|lower|match|rep|reverse|sub|upper)|table\.(?:concat|insert|maxn|remove|sort)|tonumber|tostring|type|unpack|xpcall)\b/,
-        inside: {
-          punctuation: /\./
-        }
-      },
-      boolean: /\b(?:false|true)\b/,
-      number: /(?:\B\.\d+|\b\d+\.\d+|\b\d+(?=[eE]))(?:[eE][-+]?\d+)?\b|\b(?:0x[a-fA-F\d]+|\d+)(?:U?LL)?\b/,
-      operator: /\.{3}|[-=]>|~=|(?:[-+*/%<>!=]|\.\.)=?|[:#^]|\b(?:and|or)\b=?|\b(?:not)\b/,
-      punctuation: /[.,()[\]{}\\]/
-    }, e.languages.moonscript.string[1].inside.interpolation.inside.moonscript.inside = e.languages.moonscript, e.languages.moon = e.languages.moonscript;
-  }
-  return n;
-}
-export {
-  o as __require
-};

package/dist/es/node_modules/refractor/lang/n1ql.mjs

@@ -1,34 +0,0 @@
-var T, N;
-function I() {
-  if (N)
-    return T;
-  N = 1, T = E, E.displayName = "n1ql", E.aliases = [];
-  function E(R) {
-    R.languages.n1ql = {
-      comment: {
-        pattern: /\/\*[\s\S]*?(?:$|\*\/)|--.*/,
-        greedy: !0
-      },
-      string: {
-        pattern: /(["'])(?:\\[\s\S]|(?!\1)[^\\]|\1\1)*\1/,
-        greedy: !0
-      },
-      identifier: {
-        pattern: /`(?:\\[\s\S]|[^\\`]|``)*`/,
-        greedy: !0
-      },
-      parameter: /\$[\w.]+/,
-      // https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/reservedwords.html#n1ql-reserved-words
-      keyword: /\b(?:ADVISE|ALL|ALTER|ANALYZE|AS|ASC|AT|BEGIN|BINARY|BOOLEAN|BREAK|BUCKET|BUILD|BY|CALL|CAST|CLUSTER|COLLATE|COLLECTION|COMMIT|COMMITTED|CONNECT|CONTINUE|CORRELATE|CORRELATED|COVER|CREATE|CURRENT|DATABASE|DATASET|DATASTORE|DECLARE|DECREMENT|DELETE|DERIVED|DESC|DESCRIBE|DISTINCT|DO|DROP|EACH|ELEMENT|EXCEPT|EXCLUDE|EXECUTE|EXPLAIN|FETCH|FILTER|FLATTEN|FLUSH|FOLLOWING|FOR|FORCE|FROM|FTS|FUNCTION|GOLANG|GRANT|GROUP|GROUPS|GSI|HASH|HAVING|IF|IGNORE|ILIKE|INCLUDE|INCREMENT|INDEX|INFER|INLINE|INNER|INSERT|INTERSECT|INTO|IS|ISOLATION|JAVASCRIPT|JOIN|KEY|KEYS|KEYSPACE|KNOWN|LANGUAGE|LAST|LEFT|LET|LETTING|LEVEL|LIMIT|LSM|MAP|MAPPING|MATCHED|MATERIALIZED|MERGE|MINUS|MISSING|NAMESPACE|NEST|NL|NO|NTH_VALUE|NULL|NULLS|NUMBER|OBJECT|OFFSET|ON|OPTION|OPTIONS|ORDER|OTHERS|OUTER|OVER|PARSE|PARTITION|PASSWORD|PATH|POOL|PRECEDING|PREPARE|PRIMARY|PRIVATE|PRIVILEGE|PROBE|PROCEDURE|PUBLIC|RANGE|RAW|REALM|REDUCE|RENAME|RESPECT|RETURN|RETURNING|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|SATISFIES|SAVEPOINT|SCHEMA|SCOPE|SELECT|SELF|SEMI|SET|SHOW|SOME|START|STATISTICS|STRING|SYSTEM|TIES|TO|TRAN|TRANSACTION|TRIGGER|TRUNCATE|UNBOUNDED|UNDER|UNION|UNIQUE|UNKNOWN|UNNEST|UNSET|UPDATE|UPSERT|USE|USER|USING|VALIDATE|VALUE|VALUES|VIA|VIEW|WHERE|WHILE|WINDOW|WITH|WORK|XOR)\b/i,
-      function: /\b[a-z_]\w*(?=\s*\()/i,
-      boolean: /\b(?:FALSE|TRUE)\b/i,
-      number: /(?:\b\d+\.|\B\.)\d+e[+\-]?\d+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
-      operator: /[-+*\/%]|!=|==?|\|\||<[>=]?|>=?|\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\b/i,
-      punctuation: /[;[\](),.{}:]/
-    };
-  }
-  return T;
-}
-export {
-  I as __require
-};

package/dist/es/node_modules/refractor/lang/n4js.mjs

@@ -1,22 +0,0 @@
-var t, a;
-function r() {
-  if (a)
-    return t;
-  a = 1, t = n, n.displayName = "n4js", n.aliases = ["n4jsd"];
-  function n(e) {
-    e.languages.n4js = e.languages.extend("javascript", {
-      // Keywords from N4JS language spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html
-      keyword: /\b(?:Array|any|boolean|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|false|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|module|new|null|number|package|private|protected|public|return|set|static|string|super|switch|this|throw|true|try|typeof|var|void|while|with|yield)\b/
-    }), e.languages.insertBefore("n4js", "constant", {
-      // Annotations in N4JS spec: https://numberfour.github.io/n4js/spec/N4JSSpec.html#_annotations
-      annotation: {
-        pattern: /@+\w+/,
-        alias: "operator"
-      }
-    }), e.languages.n4jsd = e.languages.n4js;
-  }
-  return t;
-}
-export {
-  r as __require
-};

package/dist/es/node_modules/refractor/lang/nand2tetris-hdl.mjs

@@ -1,21 +0,0 @@
-var n, r;
-function a() {
-  if (r)
-    return n;
-  r = 1, n = e, e.displayName = "nand2tetrisHdl", e.aliases = [];
-  function e(t) {
-    t.languages["nand2tetris-hdl"] = {
-      comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
-      keyword: /\b(?:BUILTIN|CHIP|CLOCKED|IN|OUT|PARTS)\b/,
-      boolean: /\b(?:false|true)\b/,
-      function: /\b[A-Za-z][A-Za-z0-9]*(?=\()/,
-      number: /\b\d+\b/,
-      operator: /=|\.\./,
-      punctuation: /[{}[\];(),:]/
-    };
-  }
-  return n;
-}
-export {
-  a as __require
-};

package/dist/es/node_modules/refractor/lang/naniscript.mjs

@@ -1,140 +0,0 @@
-var l, c;
-function g() {
-  if (c)
-    return l;
-  c = 1, l = i, i.displayName = "naniscript", i.aliases = [];
-  function i(d) {
-    (function(r) {
-      var s = /\{[^\r\n\[\]{}]*\}/, u = {
-        "quoted-string": {
-          pattern: /"(?:[^"\\]|\\.)*"/,
-          alias: "operator"
-        },
-        "command-param-id": {
-          pattern: /(\s)\w+:/,
-          lookbehind: !0,
-          alias: "property"
-        },
-        "command-param-value": [{
-          pattern: s,
-          alias: "selector"
-        }, {
-          pattern: /([\t ])\S+/,
-          lookbehind: !0,
-          greedy: !0,
-          alias: "operator"
-        }, {
-          pattern: /\S(?:.*\S)?/,
-          alias: "operator"
-        }]
-      };
-      r.languages.naniscript = {
-        // ; ...
-        comment: {
-          pattern: /^([\t ]*);.*/m,
-          lookbehind: !0
-        },
-        // > ...
-        // Define is a control line starting with '>' followed by a word, a space and a text.
-        define: {
-          pattern: /^>.+/m,
-          alias: "tag",
-          inside: {
-            value: {
-              pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
-              lookbehind: !0,
-              alias: "operator"
-            },
-            key: {
-              pattern: /(^>)\w+/,
-              lookbehind: !0
-            }
-          }
-        },
-        // # ...
-        label: {
-          pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
-          lookbehind: !0,
-          alias: "regex"
-        },
-        command: {
-          pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
-          lookbehind: !0,
-          alias: "function",
-          inside: {
-            "command-name": /^@\w+/,
-            expression: {
-              pattern: s,
-              greedy: !0,
-              alias: "selector"
-            },
-            "command-params": {
-              pattern: /\s*\S[\s\S]*/,
-              inside: u
-            }
-          }
-        },
-        // Generic is any line that doesn't start with operators: ;>#@
-        "generic-text": {
-          pattern: /(^[ \t]*)[^#@>;\s].*/m,
-          lookbehind: !0,
-          alias: "punctuation",
-          inside: {
-            // \{ ... \} ... \[ ... \] ... \"
-            "escaped-char": /\\[{}\[\]"]/,
-            expression: {
-              pattern: s,
-              greedy: !0,
-              alias: "selector"
-            },
-            "inline-command": {
-              pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
-              greedy: !0,
-              alias: "function",
-              inside: {
-                "command-params": {
-                  pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
-                  lookbehind: !0,
-                  inside: u
-                },
-                "command-param-name": {
-                  pattern: /^(\[[\t ]*)\w+/,
-                  lookbehind: !0,
-                  alias: "name"
-                },
-                "start-stop-char": /[\[\]]/
-              }
-            }
-          }
-        }
-      }, r.languages.nani = r.languages.naniscript, r.hooks.add("after-tokenize", function(e) {
-        var p = e.tokens;
-        p.forEach(function(a) {
-          if (typeof a != "string" && a.type === "generic-text") {
-            var t = o(a);
-            m(t) || (a.type = "bad-line", a.content = t);
-          }
-        });
-      });
-      function m(e) {
-        for (var p = "[]{}", a = [], t = 0; t < e.length; t++) {
-          var f = e[t], n = p.indexOf(f);
-          if (n !== -1) {
-            if (n % 2 === 0)
-              a.push(n + 1);
-            else if (a.pop() !== n)
-              return !1;
-          }
-        }
-        return a.length === 0;
-      }
-      function o(e) {
-        return typeof e == "string" ? e : Array.isArray(e) ? e.map(o).join("") : o(e.content);
-      }
-    })(d);
-  }
-  return l;
-}
-export {
-  g as __require
-};

package/dist/es/node_modules/refractor/lang/nasm.mjs

@@ -1,31 +0,0 @@
-var e, d;
-function n() {
-  if (d)
-    return e;
-  d = 1, e = a, a.displayName = "nasm", a.aliases = [];
-  function a(r) {
-    r.languages.nasm = {
-      comment: /;.*$/m,
-      string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-      label: {
-        pattern: /(^\s*)[A-Za-z._?$][\w.?$@~#]*:/m,
-        lookbehind: !0,
-        alias: "function"
-      },
-      keyword: [/\[?BITS (?:16|32|64)\]?/, {
-        pattern: /(^\s*)section\s*[a-z.]+:?/im,
-        lookbehind: !0
-      }, /(?:extern|global)[^;\r\n]*/i, /(?:CPU|DEFAULT|FLOAT).*$/m],
-      register: {
-        pattern: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s)\b/i,
-        alias: "variable"
-      },
-      number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\da-f]+(?:\.[\da-f]+)?)(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
-      operator: /[\[\]*+\-\/%<>=&|$!]/
-    };
-  }
-  return e;
-}
-export {
-  n as __require
-};

package/dist/es/node_modules/refractor/lang/neon.mjs

@@ -1,52 +0,0 @@
-var n, r;
-function d() {
-  if (r)
-    return n;
-  r = 1, n = e, e.displayName = "neon", e.aliases = [];
-  function e(t) {
-    t.languages.neon = {
-      comment: {
-        pattern: /#.*/,
-        greedy: !0
-      },
-      datetime: {
-        pattern: /(^|[[{(=:,\s])\d\d\d\d-\d\d?-\d\d?(?:(?:[Tt]| +)\d\d?:\d\d:\d\d(?:\.\d*)? *(?:Z|[-+]\d\d?(?::?\d\d)?)?)?(?=$|[\]}),\s])/,
-        lookbehind: !0,
-        alias: "number"
-      },
-      key: {
-        pattern: /(^|[[{(,\s])[^,:=[\]{}()'"\s]+(?=\s*:(?:$|[\]}),\s])|\s*=)/,
-        lookbehind: !0,
-        alias: "atrule"
-      },
-      number: {
-        pattern: /(^|[[{(=:,\s])[+-]?(?:0x[\da-fA-F]+|0o[0-7]+|0b[01]+|(?:\d+(?:\.\d*)?|\.?\d+)(?:[eE][+-]?\d+)?)(?=$|[\]}),:=\s])/,
-        lookbehind: !0
-      },
-      boolean: {
-        pattern: /(^|[[{(=:,\s])(?:false|no|true|yes)(?=$|[\]}),:=\s])/i,
-        lookbehind: !0
-      },
-      null: {
-        pattern: /(^|[[{(=:,\s])(?:null)(?=$|[\]}),:=\s])/i,
-        lookbehind: !0,
-        alias: "keyword"
-      },
-      string: {
-        pattern: /(^|[[{(=:,\s])(?:('''|""")\r?\n(?:(?:[^\r\n]|\r?\n(?![\t ]*\2))*\r?\n)?[\t ]*\2|'[^'\r\n]*'|"(?:\\.|[^\\"\r\n])*")/,
-        lookbehind: !0,
-        greedy: !0
-      },
-      literal: {
-        pattern: /(^|[[{(=:,\s])(?:[^#"',:=[\]{}()\s`-]|[:-][^"',=[\]{}()\s])(?:[^,:=\]})(\s]|:(?![\s,\]})]|$)|[ \t]+[^#,:=\]})(\s])*/,
-        lookbehind: !0,
-        alias: "string"
-      },
-      punctuation: /[,:=[\]{}()-]/
-    };
-  }
-  return n;
-}
-export {
-  d as __require
-};