@oslokommune/punkt-react 11.18.0 → 11.19.0

package/dist/sas-fdd3825d.js

@@ -1,363 +0,0 @@
-import { g as T } from "./index-9498f0f6.js";
-function R(s, u) {
-  for (var r = 0; r < u.length; r++) {
-    const t = u[r];
-    if (typeof t != "string" && !Array.isArray(t)) {
-      for (const e in t)
-        if (e !== "default" && !(e in s)) {
-          const a = Object.getOwnPropertyDescriptor(t, e);
-          a && Object.defineProperty(s, e, a.get ? a : {
-            enumerable: !0,
-            get: () => t[e]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(s, Symbol.toStringTag, { value: "Module" }));
-}
-var b, h;
-function x() {
-  if (h)
-    return b;
-  h = 1, b = s, s.displayName = "sas", s.aliases = [];
-  function s(u) {
-    (function(r) {
-      var t = /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))/.source, e = /\b(?:\d[\da-f]*x|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i, a = {
-        pattern: RegExp(t + "[bx]"),
-        alias: "number"
-      }, m = {
-        pattern: /&[a-z_]\w*/i
-      }, g = {
-        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"
-      }, f = {
-        pattern: /(^|\s)(?:proc\s+\w+|data(?!=)|quit|run)\b/i,
-        alias: "keyword",
-        lookbehind: !0
-      }, l = [
-        /\/\*[\s\S]*?\*\//,
-        {
-          pattern: /(^[ \t]*|;\s*)\*[^;]*;/m,
-          lookbehind: !0
-        }
-      ], i = {
-        pattern: RegExp(t),
-        greedy: !0
-      }, n = /[$%@.(){}\[\];,\\]/, c = {
-        pattern: /%?\b\w+(?=\()/,
-        alias: "keyword"
-      }, o = {
-        function: c,
-        "arg-value": {
-          pattern: /(=\s*)[A-Z\.]+/i,
-          lookbehind: !0
-        },
-        operator: /=/,
-        "macro-variable": m,
-        arg: {
-          pattern: /[A-Z]+/i,
-          alias: "keyword"
-        },
-        number: e,
-        "numeric-constant": a,
-        punctuation: n,
-        string: i
-      }, y = {
-        pattern: /\b(?:format|put)\b=?[\w'$.]+/i,
-        inside: {
-          keyword: /^(?:format|put)(?==)/i,
-          equals: /=/,
-          format: {
-            pattern: /(?:\w|\$\d)+\.\d?/,
-            alias: "number"
-          }
-        }
-      }, S = {
-        pattern: /\b(?:format|put)\s+[\w']+(?:\s+[$.\w]+)+(?=;)/i,
-        inside: {
-          keyword: /^(?:format|put)/i,
-          format: {
-            pattern: /[\w$]+\.\d?/,
-            alias: "number"
-          }
-        }
-      }, d = {
-        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"
-      }, k = {
-        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, v = {
-        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: l,
-          function: c,
-          "arg-value": o["arg-value"],
-          operator: o.operator,
-          argument: o.arg,
-          number: e,
-          "numeric-constant": a,
-          punctuation: n,
-          string: i
-        }
-      }, p = {
-        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
-      };
-      r.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 t;
-                  }
-                ),
-                "im"
-              ),
-              alias: "language-sql",
-              inside: r.languages.sql
-            },
-            "global-statements": d,
-            "sql-statements": {
-              pattern: /(^|\s)(?:disconnect\s+from|begin|commit|exec(?:ute)?|reset|rollback|validate)\b/i,
-              lookbehind: !0,
-              alias: "keyword"
-            },
-            number: e,
-            "numeric-constant": a,
-            punctuation: n,
-            string: i
-          }
-        },
-        "proc-groovy": {
-          pattern: /(^proc\s+groovy(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            comment: l,
-            groovy: {
-              pattern: RegExp(
-                /(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(
-                  /<str>/g,
-                  function() {
-                    return t;
-                  }
-                ),
-                "im"
-              ),
-              lookbehind: !0,
-              alias: "language-groovy",
-              inside: r.languages.groovy
-            },
-            keyword: p,
-            "submit-statement": k,
-            "global-statements": d,
-            number: e,
-            "numeric-constant": a,
-            punctuation: n,
-            string: i
-          }
-        },
-        "proc-lua": {
-          pattern: /(^proc\s+lua(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|data|quit|run);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            comment: l,
-            lua: {
-              pattern: RegExp(
-                /(^[ \t]*submit(?:\s+(?:load|norun|parseonly))?)(?:<str>|[^"'])+?(?=endsubmit;)/.source.replace(
-                  /<str>/g,
-                  function() {
-                    return t;
-                  }
-                ),
-                "im"
-              ),
-              lookbehind: !0,
-              alias: "language-lua",
-              inside: r.languages.lua
-            },
-            keyword: p,
-            "submit-statement": k,
-            "global-statements": d,
-            number: e,
-            "numeric-constant": a,
-            punctuation: n,
-            string: i
-          }
-        },
-        "proc-cas": {
-          pattern: /(^proc\s+cas(?:\s+[\w|=]+)?;)[\s\S]+?(?=^(?:proc\s+\w+|quit|data);|(?![\s\S]))/im,
-          lookbehind: !0,
-          inside: {
-            comment: l,
-            "statement-var": {
-              pattern: /((?:^|\s)=?)saveresult\s[^;]+/im,
-              lookbehind: !0,
-              inside: {
-                statement: {
-                  pattern: /^saveresult\s+\S+/i,
-                  inside: {
-                    keyword: /^(?:saveresult)/i
-                  }
-                },
-                rest: o
-              }
-            },
-            "cas-actions": v,
-            statement: {
-              pattern: /((?:^|\s)=?)(?:default|(?:un)?set|on|output|upload)[^;]+/im,
-              lookbehind: !0,
-              inside: o
-            },
-            step: f,
-            keyword: p,
-            function: c,
-            format: y,
-            altformat: S,
-            "global-statements": d,
-            number: e,
-            "numeric-constant": a,
-            punctuation: n,
-            string: i
-          }
-        },
-        "proc-args": {
-          pattern: RegExp(
-            /(^proc\s+\w+\s+)(?!\s)(?:[^;"']|<str>)+;/.source.replace(
-              /<str>/g,
-              function() {
-                return t;
-              }
-            ),
-            "im"
-          ),
-          lookbehind: !0,
-          inside: o
-        },
-        /*Special keywords within macros*/
-        "macro-keyword": g,
-        "macro-variable": m,
-        "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": g,
-            "macro-variable": m,
-            "escaped-char": {
-              pattern: /%['"()<>=¬^~;,#]/
-            },
-            punctuation: n
-          }
-        },
-        "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: l,
-            number: e,
-            "numeric-constant": a
-          }
-        },
-        "options-args": {
-          pattern: /(^options)[-'"|/\\<>*+=:()\w\s]*(?=;)/im,
-          lookbehind: !0,
-          inside: o
-        },
-        "cas-actions": v,
-        comment: l,
-        function: c,
-        format: y,
-        altformat: S,
-        "numeric-constant": a,
-        datetime: {
-          // '1jan2013'd, '9:25:19pm't, '18jan2003:9:27:05am'dt
-          pattern: RegExp(t + "(?:dt?|t)"),
-          alias: "number"
-        },
-        string: i,
-        step: f,
-        keyword: p,
-        // 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: n
-      };
-    })(u);
-  }
-  return b;
-}
-var E = x();
-const N = /* @__PURE__ */ T(E), L = /* @__PURE__ */ R({
-  __proto__: null,
-  default: N
-}, [E]);
-export {
-  L as s
-};

package/dist/sass-8f15af17.js

@@ -1,97 +0,0 @@
-import { g as i } from "./index-9498f0f6.js";
-function p(a, s) {
-  for (var e = 0; e < s.length; e++) {
-    const t = s[e];
-    if (typeof t != "string" && !Array.isArray(t)) {
-      for (const r in t)
-        if (r !== "default" && !(r in a)) {
-          const n = Object.getOwnPropertyDescriptor(t, r);
-          n && Object.defineProperty(a, r, n.get ? n : {
-            enumerable: !0,
-            get: () => t[r]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
-}
-var o, u;
-function g() {
-  if (u)
-    return o;
-  u = 1, o = a, a.displayName = "sass", a.aliases = [];
-  function a(s) {
-    (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]+\}/, r = [
-        /[+*\/%]|[=!]=|<=?|>=?|\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: r
-          }
-        },
-        // 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: r,
-            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
-        }
-      });
-    })(s);
-  }
-  return o;
-}
-var l = g();
-const d = /* @__PURE__ */ i(l), f = /* @__PURE__ */ p({
-  __proto__: null,
-  default: d
-}, [l]);
-export {
-  f as s
-};

package/dist/scala-44394d36.js

@@ -1,81 +0,0 @@
-import { g as c } from "./index-9498f0f6.js";
-import { r as u } from "./java-5aa325c9.js";
-function d(t, a) {
-  for (var e = 0; e < a.length; e++) {
-    const r = a[e];
-    if (typeof r != "string" && !Array.isArray(r)) {
-      for (const n in r)
-        if (n !== "default" && !(n in t)) {
-          const s = Object.getOwnPropertyDescriptor(r, n);
-          s && Object.defineProperty(t, n, s.get ? s : {
-            enumerable: !0,
-            get: () => r[n]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
-}
-var i, l;
-function g() {
-  if (l)
-    return i;
-  l = 1;
-  var t = u();
-  i = a, a.displayName = "scala", a.aliases = [];
-  function a(e) {
-    e.register(t), 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 i;
-}
-var o = g();
-const p = /* @__PURE__ */ c(o), b = /* @__PURE__ */ d({
-  __proto__: null,
-  default: p
-}, [o]);
-export {
-  b as s
-};

package/dist/scheme-61aeb1f5.js

@@ -1,123 +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 r
-};

package/dist/scheme-93208ff6.js

@@ -1,26 +0,0 @@
-import { g as a } from "./index-9498f0f6.js";
-import { r as f } from "./scheme-61aeb1f5.js";
-function i(t, c) {
-  for (var o = 0; o < c.length; o++) {
-    const e = c[o];
-    if (typeof e != "string" && !Array.isArray(e)) {
-      for (const r in e)
-        if (r !== "default" && !(r in t)) {
-          const s = Object.getOwnPropertyDescriptor(e, r);
-          s && Object.defineProperty(t, r, s.get ? s : {
-            enumerable: !0,
-            get: () => e[r]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
-}
-var n = f();
-const m = /* @__PURE__ */ a(n), g = /* @__PURE__ */ i({
-  __proto__: null,
-  default: m
-}, [n]);
-export {
-  g as s
-};