@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/sas-D7DM5vmM.js

@@ -0,0 +1,362 @@
+import { g as T } from "./index-Sj89RFCY.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-B-3W9xmk.js

@@ -0,0 +1,96 @@
+import { g as i } from "./index-Sj89RFCY.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-DmHnWeTz.js

@@ -0,0 +1,80 @@
+import { g as c } from "./index-Sj89RFCY.js";
+import { r as u } from "./java-DYIb7l3j.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-B-TWMKN_.js

@@ -0,0 +1,122 @@
+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-egHBLRqV.js

@@ -0,0 +1,26 @@
+import { g as a } from "./index-Sj89RFCY.js";
+import { r as f } from "./scheme-B-TWMKN_.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
+};