@glodon-aiot/react-components 3.3.0-beta.14 → 3.3.0-beta.17

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

@@ -0,0 +1,287 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,52 @@
+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
+};