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

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

@@ -1,305 +0,0 @@
-var m, v;
-function E() {
-  if (v)
-    return m;
-  v = 1, m = d, d.displayName = "sas", d.aliases = [];
-  function d(h) {
-    (function(o) {
-      var n = /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))/.source, e = /\b(?:\d[\da-f]*x|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i, t = {
-        pattern: RegExp(n + "[bx]"),
-        alias: "number"
-      }, p = {
-        pattern: /&[a-z_]\w*/i
-      }, b = {
-        pattern: /((?:^|\s|=|\())%(?:ABORT|BY|CMS|COPY|DISPLAY|DO|ELSE|END|EVAL|GLOBAL|GO|GOTO|IF|INC|INCLUDE|INDEX|INPUT|KTRIM|LENGTH|LET|LIST|LOCAL|PUT|QKTRIM|QSCAN|QSUBSTR|QSYSFUNC|QUPCASE|RETURN|RUN|SCAN|SUBSTR|SUPERQ|SYMDEL|SYMEXIST|SYMGLOBL|SYMLOCAL|SYSCALL|SYSEVALF|SYSEXEC|SYSFUNC|SYSGET|SYSRPUT|THEN|TO|TSO|UNQUOTE|UNTIL|UPCASE|WHILE|WINDOW)\b/i,
-        lookbehind: !0,
-        alias: "keyword"
-      }, g = {
-        pattern: /(^|\s)(?:proc\s+\w+|data(?!=)|quit|run)\b/i,
-        alias: "keyword",
-        lookbehind: !0
-      }, s = [/\/\*[\s\S]*?\*\//, {
-        pattern: /(^[ \t]*|;\s*)\*[^;]*;/m,
-        lookbehind: !0
-      }], r = {
-        pattern: RegExp(n),
-        greedy: !0
-      }, a = /[$%@.(){}\[\];,\\]/, l = {
-        pattern: /%?\b\w+(?=\()/,
-        alias: "keyword"
-      }, i = {
-        function: l,
-        "arg-value": {
-          pattern: /(=\s*)[A-Z\.]+/i,
-          lookbehind: !0
-        },
-        operator: /=/,
-        "macro-variable": p,
-        arg: {
-          pattern: /[A-Z]+/i,
-          alias: "keyword"
-        },
-        number: e,
-        "numeric-constant": t,
-        punctuation: a,
-        string: r
-      }, S = {
-        pattern: /\b(?:format|put)\b=?[\w'$.]+/i,
-        inside: {
-          keyword: /^(?:format|put)(?==)/i,
-          equals: /=/,
-          format: {
-            pattern: /(?:\w|\$\d)+\.\d?/,
-            alias: "number"
-          }
-        }
-      }, k = {
-        pattern: /\b(?:format|put)\s+[\w']+(?:\s+[$.\w]+)+(?=;)/i,
-        inside: {
-          keyword: /^(?:format|put)/i,
-          format: {
-            pattern: /[\w$]+\.\d?/,
-            alias: "number"
-          }
-        }
-      }, u = {
-        pattern: /((?:^|\s)=?)(?:catname|checkpoint execute_always|dm|endsas|filename|footnote|%include|libname|%list|lock|missing|options|page|resetline|%run|sasfile|skip|sysecho|title\d?)\b/i,
-        lookbehind: !0,
-        alias: "keyword"
-      }, y = {
-        pattern: /(^|\s)(?:submit(?:\s+(?:load|norun|parseonly))?|endsubmit)\b/i,
-        lookbehind: !0,
-        alias: "keyword"
-      }, w = /aStore|accessControl|aggregation|audio|autotune|bayesianNetClassifier|bioMedImage|boolRule|builtins|cardinality|cdm|clustering|conditionalRandomFields|configuration|copula|countreg|dataDiscovery|dataPreprocess|dataSciencePilot|dataStep|decisionTree|deduplication|deepLearn|deepNeural|deepRnn|ds2|ecm|entityRes|espCluster|explainModel|factmac|fastKnn|fcmpact|fedSql|freqTab|gVarCluster|gam|gleam|graphSemiSupLearn|hiddenMarkovModel|hyperGroup|ica|image|iml|kernalPca|langModel|ldaTopic|loadStreams|mbc|mixed|mlTools|modelPublishing|network|neuralNet|nmf|nonParametricBayes|nonlinear|optNetwork|optimization|panel|pca|percentile|phreg|pls|qkb|qlim|quantreg|recommend|regression|reinforcementLearn|robustPca|ruleMining|sampling|sandwich|sccasl|search(?:Analytics)?|sentimentAnalysis|sequence|session(?:Prop)?|severity|simSystem|simple|smartData|sparkEmbeddedProcess|sparseML|spatialreg|spc|stabilityMonitoring|svDataDescription|svm|table|text(?:Filters|Frequency|Mining|Parse|Rule(?:Develop|Score)|Topic|Util)|timeData|transpose|tsInfo|tsReconcile|uniTimeSeries|varReduce/.source, f = {
-        pattern: RegExp(/(^|\s)(?:action\s+)?(?:<act>)\.[a-z]+\b[^;]+/.source.replace(/<act>/g, function() {
-          return w;
-        }), "i"),
-        lookbehind: !0,
-        inside: {
-          keyword: RegExp(/(?:<act>)\.[a-z]+\b/.source.replace(/<act>/g, function() {
-            return w;
-          }), "i"),
-          action: {
-            pattern: /(?:action)/i,
-            alias: "keyword"
-          },
-          comment: s,
-          function: l,
-          "arg-value": i["arg-value"],
-          operator: i.operator,
-          argument: i.arg,
-          number: e,
-          "numeric-constant": t,
-          punctuation: a,
-          string: r
-        }
-      }, c = {
-        pattern: /((?:^|\s)=?)(?:after|analysis|and|array|barchart|barwidth|begingraph|by|call|cas|cbarline|cfill|class(?:lev)?|close|column|computed?|contains|continue|data(?==)|define|delete|describe|document|do\s+over|do|dol|drop|dul|else|end(?:comp|source)?|entryTitle|eval(?:uate)?|exec(?:ute)?|exit|file(?:name)?|fill(?:attrs)?|flist|fnc|function(?:list)?|global|goto|group(?:by)?|headline|headskip|histogram|if|infile|keep|keylabel|keyword|label|layout|leave|legendlabel|length|libname|loadactionset|merge|midpoints|_?null_|name|noobs|nowd|ods|options|or|otherwise|out(?:put)?|over(?:lay)?|plot|print|put|raise|ranexp|rannor|rbreak|retain|return|select|session|sessref|set|source|statgraph|sum|summarize|table|temp|terminate|then\s+do|then|title\d?|to|var|when|where|xaxisopts|y2axisopts|yaxisopts)\b/i,
-        lookbehind: !0
-      };
-      o.languages.sas = {
-        datalines: {
-          pattern: /^([ \t]*)(?:cards|(?:data)?lines);[\s\S]+?^[ \t]*;/im,
-          lookbehind: !0,
-          alias: "string",
-          inside: {
-            keyword: {
-              pattern: /^(?:cards|(?:data)?lines)/i
-            },
-            punctuation: /;/
-          }
-        },
-        "proc-sql": {
-          pattern: /(^proc\s+(?:fed)?sql(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            sql: {
-              pattern: RegExp(/^[ \t]*(?:select|alter\s+table|(?:create|describe|drop)\s+(?:index|table(?:\s+constraints)?|view)|create\s+unique\s+index|insert\s+into|update)(?:<str>|[^;"'])+;/.source.replace(/<str>/g, function() {
-                return n;
-              }), "im"),
-              alias: "language-sql",
-              inside: o.languages.sql
-            },
-            "global-statements": u,
-            "sql-statements": {
-              pattern: /(^|\s)(?:disconnect\s+from|begin|commit|exec(?:ute)?|reset|rollback|validate)\b/i,
-              lookbehind: !0,
-              alias: "keyword"
-            },
-            number: e,
-            "numeric-constant": t,
-            punctuation: a,
-            string: r
-          }
-        },
-        "proc-groovy": {
-          pattern: /(^proc\s+groovy(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            comment: s,
-            groovy: {
-              pattern: RegExp(/(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(/<str>/g, function() {
-                return n;
-              }), "im"),
-              lookbehind: !0,
-              alias: "language-groovy",
-              inside: o.languages.groovy
-            },
-            keyword: c,
-            "submit-statement": y,
-            "global-statements": u,
-            number: e,
-            "numeric-constant": t,
-            punctuation: a,
-            string: r
-          }
-        },
-        "proc-lua": {
-          pattern: /(^proc\s+lua(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            comment: s,
-            lua: {
-              pattern: RegExp(/(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(/<str>/g, function() {
-                return n;
-              }), "im"),
-              lookbehind: !0,
-              alias: "language-lua",
-              inside: o.languages.lua
-            },
-            keyword: c,
-            "submit-statement": y,
-            "global-statements": u,
-            number: e,
-            "numeric-constant": t,
-            punctuation: a,
-            string: r
-          }
-        },
-        "proc-cas": {
-          pattern: /(^proc\s+cas(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|quit|data);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            comment: s,
-            "statement-var": {
-              pattern: /((?:^|\s)=?)saveresult\s[^;]+/im,
-              lookbehind: !0,
-              inside: {
-                statement: {
-                  pattern: /^saveresult\s+\S+/i,
-                  inside: {
-                    keyword: /^(?:saveresult)/i
-                  }
-                },
-                rest: i
-              }
-            },
-            "cas-actions": f,
-            statement: {
-              pattern: /((?:^|\s)=?)(?:default|(?:un)?set|on|output|upload)[^;]+/im,
-              lookbehind: !0,
-              inside: i
-            },
-            step: g,
-            keyword: c,
-            function: l,
-            format: S,
-            altformat: k,
-            "global-statements": u,
-            number: e,
-            "numeric-constant": t,
-            punctuation: a,
-            string: r
-          }
-        },
-        "proc-args": {
-          pattern: RegExp(/(^proc\s+\w+\s+)(?!\s)(?:[^;"']|<str>)+;/.source.replace(/<str>/g, function() {
-            return n;
-          }), "im"),
-          lookbehind: !0,
-          inside: i
-        },
-        /*Special keywords within macros*/
-        "macro-keyword": b,
-        "macro-variable": p,
-        "macro-string-functions": {
-          pattern: /((?:^|\s|=))%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)\(.*?(?:[^%]\))/i,
-          lookbehind: !0,
-          inside: {
-            function: {
-              pattern: /%(?:BQUOTE|NRBQUOTE|NRQUOTE|NRSTR|QUOTE|STR)/i,
-              alias: "keyword"
-            },
-            "macro-keyword": b,
-            "macro-variable": p,
-            "escaped-char": {
-              pattern: /%['"()<>=¬^~;,#]/
-            },
-            punctuation: a
-          }
-        },
-        "macro-declaration": {
-          pattern: /^%macro[^;]+(?=;)/im,
-          inside: {
-            keyword: /%macro/i
-          }
-        },
-        "macro-end": {
-          pattern: /^%mend[^;]+(?=;)/im,
-          inside: {
-            keyword: /%mend/i
-          }
-        },
-        /*%_zscore(headcir, _lhc, _mhc, _shc, headcz, headcpct, _Fheadcz); */
-        macro: {
-          pattern: /%_\w+(?=\()/,
-          alias: "keyword"
-        },
-        input: {
-          pattern: /\binput\s[-\w\s/*.$&]+;/i,
-          inside: {
-            input: {
-              alias: "keyword",
-              pattern: /^input/i
-            },
-            comment: s,
-            number: e,
-            "numeric-constant": t
-          }
-        },
-        "options-args": {
-          pattern: /(^options)[-'"|/\\<>*+=:()\w\s]*(?=;)/im,
-          lookbehind: !0,
-          inside: i
-        },
-        "cas-actions": f,
-        comment: s,
-        function: l,
-        format: S,
-        altformat: k,
-        "numeric-constant": t,
-        datetime: {
-          // '1jan2013'd, '9:25:19pm't, '18jan2003:9:27:05am'dt
-          pattern: RegExp(n + "(?:dt?|t)"),
-          alias: "number"
-        },
-        string: r,
-        step: g,
-        keyword: c,
-        // In SAS Studio syntax highlighting, these operators are styled like keywords
-        "operator-keyword": {
-          pattern: /\b(?:eq|ge|gt|in|le|lt|ne|not)\b/i,
-          alias: "operator"
-        },
-        // Decimal (1.2e23), hexadecimal (0c1x)
-        number: e,
-        operator: /\*\*?|\|\|?|!!?|¦¦?|<[>=]?|>[<=]?|[-+\/=&]|[~¬^]=?/,
-        punctuation: a
-      };
-    })(h);
-  }
-  return m;
-}
-export {
-  E as __require
-};

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

@@ -1,69 +0,0 @@
-var r, n;
-function o() {
-  if (n)
-    return r;
-  n = 1, r = a, a.displayName = "sass", a.aliases = [];
-  function a(u) {
-    (function(e) {
-      e.languages.sass = e.languages.extend("css", {
-        // Sass comments don't need to be closed, only indented
-        comment: {
-          pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
-          lookbehind: !0,
-          greedy: !0
-        }
-      }), e.languages.insertBefore("sass", "atrule", {
-        // We want to consume the whole line
-        "atrule-line": {
-          // Includes support for = and + shortcuts
-          pattern: /^(?:[ \t]*)[@+=].+/m,
-          greedy: !0,
-          inside: {
-            atrule: /(?:@[\w-]+|[+=])/
-          }
-        }
-      }), delete e.languages.sass.atrule;
-      var t = /\$[-\w]+|#\{\$[-\w]+\}/, s = [/[+*\/%]|[=!]=|<=?|>=?|\b(?:and|not|or)\b/, {
-        pattern: /(\s)-(?=\s)/,
-        lookbehind: !0
-      }];
-      e.languages.insertBefore("sass", "property", {
-        // We want to consume the whole line
-        "variable-line": {
-          pattern: /^[ \t]*\$.+/m,
-          greedy: !0,
-          inside: {
-            punctuation: /:/,
-            variable: t,
-            operator: s
-          }
-        },
-        // We want to consume the whole line
-        "property-line": {
-          pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s].*)/m,
-          greedy: !0,
-          inside: {
-            property: [/[^:\s]+(?=\s*:)/, {
-              pattern: /(:)[^:\s]+/,
-              lookbehind: !0
-            }],
-            punctuation: /:/,
-            variable: t,
-            operator: s,
-            important: e.languages.sass.important
-          }
-        }
-      }), delete e.languages.sass.property, delete e.languages.sass.important, e.languages.insertBefore("sass", "punctuation", {
-        selector: {
-          pattern: /^([ \t]*)\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*)*/m,
-          lookbehind: !0,
-          greedy: !0
-        }
-      });
-    })(u);
-  }
-  return r;
-}
-export {
-  o as __require
-};

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

@@ -1,59 +0,0 @@
-import { __require as i } from "./java.mjs";
-var t, r;
-function s() {
-  if (r)
-    return t;
-  r = 1;
-  var n = i();
-  t = a, a.displayName = "scala", a.aliases = [];
-  function a(e) {
-    e.register(n), e.languages.scala = e.languages.extend("java", {
-      "triple-quoted-string": {
-        pattern: /"""[\s\S]*?"""/,
-        greedy: !0,
-        alias: "string"
-      },
-      string: {
-        pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        greedy: !0
-      },
-      keyword: /<-|=>|\b(?:abstract|case|catch|class|def|do|else|extends|final|finally|for|forSome|if|implicit|import|lazy|match|new|null|object|override|package|private|protected|return|sealed|self|super|this|throw|trait|try|type|val|var|while|with|yield)\b/,
-      number: /\b0x(?:[\da-f]*\.)?[\da-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e\d+)?[dfl]?/i,
-      builtin: /\b(?:Any|AnyRef|AnyVal|Boolean|Byte|Char|Double|Float|Int|Long|Nothing|Short|String|Unit)\b/,
-      symbol: /'[^\d\s\\]\w*/
-    }), e.languages.insertBefore("scala", "triple-quoted-string", {
-      "string-interpolation": {
-        pattern: /\b[a-z]\w*(?:"""(?:[^$]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*?"""|"(?:[^$"\r\n]|\$(?:[^{]|\{(?:[^{}]|\{[^{}]*\})*\}))*")/i,
-        greedy: !0,
-        inside: {
-          id: {
-            pattern: /^\w+/,
-            greedy: !0,
-            alias: "function"
-          },
-          escape: {
-            pattern: /\\\$"|\$[$"]/,
-            greedy: !0,
-            alias: "symbol"
-          },
-          interpolation: {
-            pattern: /\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
-            greedy: !0,
-            inside: {
-              punctuation: /^\$\{?|\}$/,
-              expression: {
-                pattern: /[\s\S]+/,
-                inside: e.languages.scala
-              }
-            }
-          },
-          string: /[\s\S]+/
-        }
-      }
-    }), delete e.languages.scala["class-name"], delete e.languages.scala.function;
-  }
-  return t;
-}
-export {
-  s as __require
-};

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

@@ -1,120 +0,0 @@
-var n, o;
-function s() {
-  if (o)
-    return n;
-  o = 1, n = r, r.displayName = "scheme", r.aliases = [];
-  function r(a) {
-    (function(i) {
-      i.languages.scheme = {
-        // this supports "normal" single-line comments:
-        //   ; comment
-        // and (potentially nested) multiline comments:
-        //   #| comment #| nested |# still comment |#
-        // (only 1 level of nesting is supported)
-        comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
-        string: {
-          pattern: /"(?:[^"\\]|\\.)*"/,
-          greedy: !0
-        },
-        symbol: {
-          pattern: /'[^()\[\]#'\s]+/,
-          greedy: !0
-        },
-        char: {
-          pattern: /#\\(?:[ux][a-fA-F\d]+\b|[-a-zA-Z]+\b|[\uD800-\uDBFF][\uDC00-\uDFFF]|\S)/,
-          greedy: !0
-        },
-        "lambda-parameter": [
-          // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30
-          {
-            pattern: /((?:^|[^'`#])[(\[]lambda\s+)(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)/,
-            lookbehind: !0
-          },
-          {
-            pattern: /((?:^|[^'`#])[(\[]lambda\s+[(\[])[^()\[\]']+/,
-            lookbehind: !0
-          }
-        ],
-        keyword: {
-          pattern: /((?:^|[^'`#])[(\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\*)?|let\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\[\]\s]|$)/,
-          lookbehind: !0
-        },
-        builtin: {
-          // all functions of the base library of R7RS plus some of built-ins of R5Rs
-          pattern: /((?:^|[^'`#])[(\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\?|boolean=?\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\?|\?|<\?|<=\?|=\?|>\?|>=\?)|close-(?:input-port|output-port|port)|complex\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\??|eq\?|equal\?|eqv\?|error|error-object(?:-irritants|-message|\?)|eval|even\?|exact(?:-integer-sqrt|-integer\?|\?)?|expt|features|file-error\?|floor(?:-quotient|-remainder|\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\??|input-port(?:-open\?|\?)|integer(?:->char|\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\?|newline|not|null\?|number(?:->string|\?)|numerator|odd\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\?|\?)|pair\?|peek-char|peek-u8|port\?|positive\?|procedure\?|quotient|raise|raise-continuable|rational\?|rationalize|read-(?:bytevector|bytevector!|char|error\?|line|string|u8)|real\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?|<\?|<=\?|=\?|>\?|>=\?)?|substring|symbol(?:->string|\?|=\?)|syntax-error|textual-port\?|truncate(?:-quotient|-remainder|\/)?|u8-ready\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\?)(?=[()\[\]\s]|$)/,
-          lookbehind: !0
-        },
-        operator: {
-          pattern: /((?:^|[^'`#])[(\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\[\]\s]|$)/,
-          lookbehind: !0
-        },
-        number: {
-          // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).
-          //
-          // <number>      := <num 2>|<num 8>|<num 10>|<num 16>
-          // <num R>       := <prefix R><complex R>
-          // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>
-          // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\.0)?i
-          // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\.0
-          // <ureal R>     := <uint R>(?:\/<uint R>)?
-          //                | <decimal R>
-          //
-          // <decimal 10>  := (?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?
-          // <uint R>      := <digit R>+
-          // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>
-          // <radix 2>     := #b
-          // <radix 8>     := #o
-          // <radix 10>    := (?:#d)?
-          // <radix 16>    := #x
-          // <digit 2>     := [01]
-          // <digit 8>     := [0-7]
-          // <digit 10>    := \d
-          // <digit 16>    := [0-9a-f]
-          //
-          // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all
-          // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)
-          // pattern:
-          pattern: RegExp(u({
-            "<ureal dec>": /\d+(?:\/\d+)|(?:\d+(?:\.\d*)?|\.\d+)(?:[esfdl][+-]?\d+)?/.source,
-            "<real dec>": /[+-]?<ureal dec>|[+-](?:inf|nan)\.0/.source,
-            "<imaginary dec>": /[+-](?:<ureal dec>|(?:inf|nan)\.0)?i/.source,
-            "<complex dec>": /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/.source,
-            "<num dec>": /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,
-            "<ureal box>": /[0-9a-f]+(?:\/[0-9a-f]+)?/.source,
-            "<real box>": /[+-]?<ureal box>|[+-](?:inf|nan)\.0/.source,
-            "<imaginary box>": /[+-](?:<ureal box>|(?:inf|nan)\.0)?i/.source,
-            "<complex box>": /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/.source,
-            "<num box>": /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/.source,
-            "<number>": /(^|[()\[\]\s])(?:<num dec>|<num box>)(?=[()\[\]\s]|$)/.source
-          }), "i"),
-          lookbehind: !0
-        },
-        boolean: {
-          pattern: /(^|[()\[\]\s])#(?:[ft]|false|true)(?=[()\[\]\s]|$)/,
-          lookbehind: !0
-        },
-        function: {
-          pattern: /((?:^|[^'`#])[(\[])(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)(?=[()\[\]\s]|$)/,
-          lookbehind: !0
-        },
-        identifier: {
-          pattern: /(^|[()\[\]\s])\|(?:[^\\|]|\\.)*\|(?=[()\[\]\s]|$)/,
-          lookbehind: !0,
-          greedy: !0
-        },
-        punctuation: /[()\[\]']/
-      };
-      function u(e) {
-        for (var t in e)
-          e[t] = e[t].replace(/<[\w\s]+>/g, function(c) {
-            return "(?:" + e[c].trim() + ")";
-          });
-        return e[t];
-      }
-    })(a);
-  }
-  return n;
-}
-export {
-  s as __require
-};

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

@@ -1,82 +0,0 @@
-var a, t;
-function r() {
-  if (t)
-    return a;
-  t = 1, a = s, s.displayName = "scss", s.aliases = [];
-  function s(e) {
-    e.languages.scss = e.languages.extend("css", {
-      comment: {
-        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
-        lookbehind: !0
-      },
-      atrule: {
-        pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
-        inside: {
-          rule: /@[\w-]+/
-          // See rest below
-        }
-      },
-      // url, compassified
-      url: /(?:[-a-z]+-)?url(?=\()/i,
-      // CSS selector regex is not appropriate for Sass
-      // since there can be lot more things (var, @ directive, nesting..)
-      // a selector must start at the end of a property or after a brace (end of other rules or nesting)
-      // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
-      // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
-      // can "pass" as a selector- e.g: proper#{$erty})
-      // this one was hard to do, so please be careful if you edit this one :)
-      selector: {
-        // Initial look-ahead is used to prevent matching of blank selectors
-        pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
-        inside: {
-          parent: {
-            pattern: /&/,
-            alias: "important"
-          },
-          placeholder: /%[-\w]+/,
-          variable: /\$[-\w]+|#\{\$[-\w]+\}/
-        }
-      },
-      property: {
-        pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
-        inside: {
-          variable: /\$[-\w]+|#\{\$[-\w]+\}/
-        }
-      }
-    }), e.languages.insertBefore("scss", "atrule", {
-      keyword: [/@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i, {
-        pattern: /( )(?:from|through)(?= )/,
-        lookbehind: !0
-      }]
-    }), e.languages.insertBefore("scss", "important", {
-      // var and interpolated vars
-      variable: /\$[-\w]+|#\{\$[-\w]+\}/
-    }), e.languages.insertBefore("scss", "function", {
-      "module-modifier": {
-        pattern: /\b(?:as|hide|show|with)\b/i,
-        alias: "keyword"
-      },
-      placeholder: {
-        pattern: /%[-\w]+/,
-        alias: "selector"
-      },
-      statement: {
-        pattern: /\B!(?:default|optional)\b/i,
-        alias: "keyword"
-      },
-      boolean: /\b(?:false|true)\b/,
-      null: {
-        pattern: /\bnull\b/,
-        alias: "keyword"
-      },
-      operator: {
-        pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
-        lookbehind: !0
-      }
-    }), e.languages.scss.atrule.inside.rest = e.languages.scss;
-  }
-  return a;
-}
-export {
-  r as __require
-};