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

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

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

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

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

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

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