@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/pug-C7olXkyh.js

@@ -0,0 +1,212 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function d(a, s) {
+  for (var e = 0; e < s.length; e++) {
+    const r = s[e];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in a)) {
+          const i = Object.getOwnPropertyDescriptor(r, n);
+          i && Object.defineProperty(a, n, i.get ? i : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var u, o;
+function f() {
+  if (o) return u;
+  o = 1, u = a, a.displayName = "pug", a.aliases = [];
+  function a(s) {
+    (function(e) {
+      e.languages.pug = {
+        // Multiline stuff should appear before the rest
+        // This handles both single-line and multi-line comments
+        comment: {
+          pattern: /(^([\t ]*))\/\/.*(?:(?:\r?\n|\r)\2[\t ].+)*/m,
+          lookbehind: !0
+        },
+        // All the tag-related part is in lookbehind
+        // so that it can be highlighted by the "tag" pattern
+        "multiline-script": {
+          pattern: /(^([\t ]*)script\b.*\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        // See at the end of the file for known filters
+        filter: {
+          pattern: /(^([\t ]*)):.+(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
+          lookbehind: !0,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "variable"
+            },
+            text: /\S[\s\S]*/
+          }
+        },
+        "multiline-plain-text": {
+          pattern: /(^([\t ]*)[\w\-#.]+\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
+          lookbehind: !0
+        },
+        markup: {
+          pattern: /(^[\t ]*)<.+/m,
+          lookbehind: !0,
+          inside: e.languages.markup
+        },
+        doctype: {
+          pattern: /((?:^|\n)[\t ]*)doctype(?: .+)?/,
+          lookbehind: !0
+        },
+        // This handle all conditional and loop keywords
+        "flow-control": {
+          pattern: /(^[\t ]*)(?:case|default|each|else|if|unless|when|while)\b(?: .+)?/m,
+          lookbehind: !0,
+          inside: {
+            each: {
+              pattern: /^each .+? in\b/,
+              inside: {
+                keyword: /\b(?:each|in)\b/,
+                punctuation: /,/
+              }
+            },
+            branch: {
+              pattern: /^(?:case|default|else|if|unless|when|while)\b/,
+              alias: "keyword"
+            },
+            rest: e.languages.javascript
+          }
+        },
+        keyword: {
+          pattern: /(^[\t ]*)(?:append|block|extends|include|prepend)\b.+/m,
+          lookbehind: !0
+        },
+        mixin: [
+          // Declaration
+          {
+            pattern: /(^[\t ]*)mixin .+/m,
+            lookbehind: !0,
+            inside: {
+              keyword: /^mixin/,
+              function: /\w+(?=\s*\(|\s*$)/,
+              punctuation: /[(),.]/
+            }
+          },
+          // Usage
+          {
+            pattern: /(^[\t ]*)\+.+/m,
+            lookbehind: !0,
+            inside: {
+              name: {
+                pattern: /^\+\w+/,
+                alias: "function"
+              },
+              rest: e.languages.javascript
+            }
+          }
+        ],
+        script: {
+          pattern: /(^[\t ]*script(?:(?:&[^(]+)?\([^)]+\))*[\t ]).+/m,
+          lookbehind: !0,
+          inside: e.languages.javascript
+        },
+        "plain-text": {
+          pattern: /(^[\t ]*(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?[\t ]).+/m,
+          lookbehind: !0
+        },
+        tag: {
+          pattern: /(^[\t ]*)(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?:?/m,
+          lookbehind: !0,
+          inside: {
+            attributes: [
+              {
+                pattern: /&[^(]+\([^)]+\)/,
+                inside: e.languages.javascript
+              },
+              {
+                pattern: /\([^)]+\)/,
+                inside: {
+                  "attr-value": {
+                    pattern: /(=\s*(?!\s))(?:\{[^}]*\}|[^,)\r\n]+)/,
+                    lookbehind: !0,
+                    inside: e.languages.javascript
+                  },
+                  "attr-name": /[\w-]+(?=\s*!?=|\s*[,)])/,
+                  punctuation: /[!=(),]+/
+                }
+              }
+            ],
+            punctuation: /:/,
+            "attr-id": /#[\w\-]+/,
+            "attr-class": /\.[\w\-]+/
+          }
+        },
+        code: [
+          {
+            pattern: /(^[\t ]*(?:-|!?=)).+/m,
+            lookbehind: !0,
+            inside: e.languages.javascript
+          }
+        ],
+        punctuation: /[.\-!=|]+/
+      };
+      for (var r = /(^([\t ]*)):<filter_name>(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/.source, n = [
+        {
+          filter: "atpl",
+          language: "twig"
+        },
+        {
+          filter: "coffee",
+          language: "coffeescript"
+        },
+        "ejs",
+        "handlebars",
+        "less",
+        "livescript",
+        "markdown",
+        {
+          filter: "sass",
+          language: "scss"
+        },
+        "stylus"
+      ], i = {}, l = 0, g = n.length; l < g; l++) {
+        var t = n[l];
+        t = typeof t == "string" ? {
+          filter: t,
+          language: t
+        } : t, e.languages[t.language] && (i["filter-" + t.filter] = {
+          pattern: RegExp(
+            r.replace("<filter_name>", function() {
+              return t.filter;
+            }),
+            "m"
+          ),
+          lookbehind: !0,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "variable"
+            },
+            text: {
+              pattern: /\S[\s\S]*/,
+              alias: [t.language, "language-" + t.language],
+              inside: e.languages[t.language]
+            }
+          }
+        });
+      }
+      e.languages.insertBefore("pug", "filter", i);
+    })(s);
+  }
+  return u;
+}
+var p = f();
+const b = /* @__PURE__ */ c(p), m = /* @__PURE__ */ d({
+  __proto__: null,
+  default: b
+}, [p]);
+export {
+  m as p
+};

package/dist/puppet-DMdAuQ_Z.js

@@ -0,0 +1,167 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function l(n, a) {
+  for (var e = 0; e < a.length; e++) {
+    const t = a[e];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in n)) {
+          const i = Object.getOwnPropertyDescriptor(t, r);
+          i && Object.defineProperty(n, r, i.get ? i : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var o, u;
+function d() {
+  if (u) return o;
+  u = 1, o = n, n.displayName = "puppet", n.aliases = [];
+  function n(a) {
+    (function(e) {
+      e.languages.puppet = {
+        heredoc: [
+          // Matches the content of a quoted heredoc string (subject to interpolation)
+          {
+            pattern: /(@\("([^"\r\n\/):]+)"(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
+            lookbehind: !0,
+            alias: "string",
+            inside: {
+              // Matches the end tag
+              punctuation: /(?=\S).*\S(?= *$)/
+              // See interpolation below
+            }
+          },
+          // Matches the content of an unquoted heredoc string (no interpolation)
+          {
+            pattern: /(@\(([^"\r\n\/):]+)(?:\/[nrts$uL]*)?\).*(?:\r?\n|\r))(?:.*(?:\r?\n|\r(?!\n)))*?[ \t]*(?:\|[ \t]*)?(?:-[ \t]*)?\2/,
+            lookbehind: !0,
+            greedy: !0,
+            alias: "string",
+            inside: {
+              // Matches the end tag
+              punctuation: /(?=\S).*\S(?= *$)/
+            }
+          },
+          // Matches the start tag of heredoc strings
+          {
+            pattern: /@\("?(?:[^"\r\n\/):]+)"?(?:\/[nrts$uL]*)?\)/,
+            alias: "string",
+            inside: {
+              punctuation: {
+                pattern: /(\().+?(?=\))/,
+                lookbehind: !0
+              }
+            }
+          }
+        ],
+        "multiline-comment": {
+          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "comment"
+        },
+        regex: {
+          // Must be prefixed with the keyword "node" or a non-word char
+          pattern: /((?:\bnode\s+|[~=\(\[\{,]\s*|[=+]>\s*|^\s*))\/(?:[^\/\\]|\\[\s\S])+\/(?:[imx]+\b|\B)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            // Extended regexes must have the x flag. They can contain single-line comments.
+            "extended-regex": {
+              pattern: /^\/(?:[^\/\\]|\\[\s\S])+\/[im]*x[im]*$/,
+              inside: {
+                comment: /#.*/
+              }
+            }
+          }
+        },
+        comment: {
+          pattern: /(^|[^\\])#.*/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        string: {
+          // Allow for one nested level of double quotes inside interpolation
+          pattern: /(["'])(?:\$\{(?:[^'"}]|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}|\$(?!\{)|(?!\1)[^\\$]|\\[\s\S])*\1/,
+          greedy: !0,
+          inside: {
+            "double-quoted": {
+              pattern: /^"[\s\S]*"$/,
+              inside: {
+                // See interpolation below
+              }
+            }
+          }
+        },
+        variable: {
+          pattern: /\$(?:::)?\w+(?:::\w+)*/,
+          inside: {
+            punctuation: /::/
+          }
+        },
+        "attr-name": /(?:\b\w+|\*)(?=\s*=>)/,
+        function: [
+          {
+            pattern: /(\.)(?!\d)\w+/,
+            lookbehind: !0
+          },
+          /\b(?:contain|debug|err|fail|include|info|notice|realize|require|tag|warning)\b|\b(?!\d)\w+(?=\()/
+        ],
+        number: /\b(?:0x[a-f\d]+|\d+(?:\.\d+)?(?:e-?\d+)?)\b/i,
+        boolean: /\b(?:false|true)\b/,
+        // Includes words reserved for future use
+        keyword: /\b(?:application|attr|case|class|consumes|default|define|else|elsif|function|if|import|inherits|node|private|produces|type|undef|unless)\b/,
+        datatype: {
+          pattern: /\b(?:Any|Array|Boolean|Callable|Catalogentry|Class|Collection|Data|Default|Enum|Float|Hash|Integer|NotUndef|Numeric|Optional|Pattern|Regexp|Resource|Runtime|Scalar|String|Struct|Tuple|Type|Undef|Variant)\b/,
+          alias: "symbol"
+        },
+        operator: /=[=~>]?|![=~]?|<(?:<\|?|[=~|-])?|>[>=]?|->?|~>|\|>?>?|[*\/%+?]|\b(?:and|in|or)\b/,
+        punctuation: /[\[\]{}().,;]|:+/
+      };
+      var t = [
+        {
+          // Allow for one nested level of braces inside interpolation
+          pattern: /(^|[^\\])\$\{(?:[^'"{}]|\{[^}]*\}|(["'])(?:(?!\2)[^\\]|\\[\s\S])*\2)+\}/,
+          lookbehind: !0,
+          inside: {
+            "short-variable": {
+              // Negative look-ahead prevent wrong highlighting of functions
+              pattern: /(^\$\{)(?!\w+\()(?:::)?\w+(?:::\w+)*/,
+              lookbehind: !0,
+              alias: "variable",
+              inside: {
+                punctuation: /::/
+              }
+            },
+            delimiter: {
+              pattern: /^\$/,
+              alias: "variable"
+            },
+            rest: e.languages.puppet
+          }
+        },
+        {
+          pattern: /(^|[^\\])\$(?:::)?\w+(?:::\w+)*/,
+          lookbehind: !0,
+          alias: "variable",
+          inside: {
+            punctuation: /::/
+          }
+        }
+      ];
+      e.languages.puppet.heredoc[0].inside.interpolation = t, e.languages.puppet.string.inside["double-quoted"].inside.interpolation = t;
+    })(a);
+  }
+  return o;
+}
+var p = d();
+const b = /* @__PURE__ */ s(p), g = /* @__PURE__ */ l({
+  __proto__: null,
+  default: b
+}, [p]);
+export {
+  g as p
+};

package/dist/pure-BVQraXQo.js

@@ -0,0 +1,111 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(r, p) {
+  for (var e = 0; e < p.length; e++) {
+    const a = p[e];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const n in a)
+        if (n !== "default" && !(n in r)) {
+          const t = Object.getOwnPropertyDescriptor(a, n);
+          t && Object.defineProperty(r, n, t.get ? t : {
+            enumerable: !0,
+            get: () => a[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var l, s;
+function f() {
+  if (s) return l;
+  s = 1, l = r, r.displayName = "pure", r.aliases = [];
+  function r(p) {
+    (function(e) {
+      e.languages.pure = {
+        comment: [
+          {
+            pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+            lookbehind: !0
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: !0
+          },
+          /#!.+/
+        ],
+        "inline-lang": {
+          pattern: /%<[\s\S]+?%>/,
+          greedy: !0,
+          inside: {
+            lang: {
+              pattern: /(^%< *)-\*-.+?-\*-/,
+              lookbehind: !0,
+              alias: "comment"
+            },
+            delimiter: {
+              pattern: /^%<.*|%>$/,
+              alias: "punctuation"
+            }
+          }
+        },
+        string: {
+          pattern: /"(?:\\.|[^"\\\r\n])*"/,
+          greedy: !0
+        },
+        number: {
+          // The look-behind prevents wrong highlighting of the .. operator
+          pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
+          lookbehind: !0
+        },
+        keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
+        function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
+        special: {
+          pattern: /\b__[a-z]+__\b/i,
+          alias: "builtin"
+        },
+        // Any combination of operator chars can be an operator
+        // eslint-disable-next-line no-misleading-character-class
+        operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
+        // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?
+        punctuation: /[(){}\[\];,|]/
+      };
+      var a = [
+        "c",
+        {
+          lang: "c++",
+          alias: "cpp"
+        },
+        "fortran"
+      ], n = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
+      a.forEach(function(t) {
+        var i = t;
+        if (typeof t != "string" && (i = t.alias, t = t.lang), e.languages[i]) {
+          var o = {};
+          o["inline-lang-" + i] = {
+            pattern: RegExp(
+              n.replace(
+                "<lang>",
+                t.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")
+              ),
+              "i"
+            ),
+            inside: e.util.clone(e.languages.pure["inline-lang"].inside)
+          }, o["inline-lang-" + i].inside.rest = e.util.clone(
+            e.languages[i]
+          ), e.languages.insertBefore("pure", "inline-lang", o);
+        }
+      }), e.languages.c && (e.languages.pure["inline-lang"].inside.rest = e.util.clone(
+        e.languages.c
+      ));
+    })(p);
+  }
+  return l;
+}
+var c = f();
+const g = /* @__PURE__ */ u(c), b = /* @__PURE__ */ d({
+  __proto__: null,
+  default: g
+}, [c]);
+export {
+  b as p
+};

package/dist/purebasic-DnAwivDW.js

@@ -0,0 +1,87 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function c(r, e) {
+  for (var d = 0; d < e.length; d++) {
+    const a = e[d];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const t in a)
+        if (t !== "default" && !(t in r)) {
+          const n = Object.getOwnPropertyDescriptor(a, t);
+          n && Object.defineProperty(r, t, n.get ? n : {
+            enumerable: !0,
+            get: () => a[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var l, i;
+function u() {
+  if (i) return l;
+  i = 1, l = r, r.displayName = "purebasic", r.aliases = [];
+  function r(e) {
+    e.languages.purebasic = e.languages.extend("clike", {
+      comment: /;.*/,
+      keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
+      function: /\b\w+(?:\.\w+)?\s*(?=\()/,
+      number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
+      operator: /(?:@\*?|\?|\*)\w+|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
+    }), e.languages.insertBefore("purebasic", "keyword", {
+      tag: /#\w+\$?/,
+      asm: {
+        pattern: /(^[\t ]*)!.*/m,
+        lookbehind: !0,
+        alias: "tag",
+        inside: {
+          comment: /;.*/,
+          string: {
+            pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+            greedy: !0
+          },
+          // Anonymous label references, i.e.: jmp @b
+          "label-reference-anonymous": {
+            pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
+            lookbehind: !0,
+            alias: "fasm-label"
+          },
+          // Named label reference, i.e.: jne label1
+          "label-reference-addressed": {
+            pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
+            lookbehind: !0,
+            alias: "fasm-label"
+          },
+          keyword: [
+            /\b(?:extern|global)\b[^;\r\n]*/i,
+            /\b(?:CPU|DEFAULT|FLOAT)\b.*/
+          ],
+          function: {
+            pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
+            lookbehind: !0
+          },
+          "function-inline": {
+            pattern: /(:\s*)[\da-z]+(?=\s)/i,
+            lookbehind: !0,
+            alias: "function"
+          },
+          label: {
+            pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
+            lookbehind: !0,
+            alias: "fasm-label"
+          },
+          register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
+          number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+          operator: /[\[\]*+\-/%<>=&|$!,.:]/
+        }
+      }
+    }), delete e.languages.purebasic["class-name"], delete e.languages.purebasic.boolean, e.languages.pbfasm = e.languages.purebasic;
+  }
+  return l;
+}
+var o = u();
+const b = /* @__PURE__ */ s(o), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: b
+}, [o]);
+export {
+  f as p
+};

package/dist/purescript-BBcUX3cf.js

@@ -0,0 +1,62 @@
+import { g as d } from "./index-Sj89RFCY.js";
+import { r as n } from "./haskell-DR6jYji5.js";
+function b(f, e) {
+  for (var u = 0; u < e.length; u++) {
+    const a = e[u];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const r in a)
+        if (r !== "default" && !(r in f)) {
+          const t = Object.getOwnPropertyDescriptor(a, r);
+          t && Object.defineProperty(f, r, t.get ? t : {
+            enumerable: !0,
+            get: () => a[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(f, Symbol.toStringTag, { value: "Module" }));
+}
+var c, i;
+function s() {
+  if (i) return c;
+  i = 1;
+  var f = n();
+  c = e, e.displayName = "purescript", e.aliases = ["purs"];
+  function e(u) {
+    u.register(f), u.languages.purescript = u.languages.extend("haskell", {
+      keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
+      "import-statement": {
+        // The imported or hidden names are not included in this import
+        // statement. This is because we want to highlight those exactly like
+        // we do for the names in the program.
+        pattern: /(^[\t ]*)import\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*(?:\s+as\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+        lookbehind: !0,
+        inside: {
+          keyword: /\b(?:as|hiding|import)\b/,
+          punctuation: /\./
+        }
+      },
+      // These are builtin functions only. Constructors are highlighted later as a constant.
+      builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
+      operator: [
+        // Infix operators
+        u.languages.haskell.operator[0],
+        // ASCII operators
+        u.languages.haskell.operator[2],
+        // All UTF16 Unicode operator symbols
+        // This regex is equivalent to /(?=[\x80-\uFFFF])[\p{gc=Math_Symbol}\p{gc=Currency_Symbol}\p{Modifier_Symbol}\p{Other_Symbol}]/u
+        // See https://github.com/PrismJS/prism/issues/3006 for more details.
+        /[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
+      ]
+    }), u.languages.purs = u.languages.purescript;
+  }
+  return c;
+}
+var o = s();
+const p = /* @__PURE__ */ d(o), m = /* @__PURE__ */ b({
+  __proto__: null,
+  default: p
+}, [o]);
+export {
+  m as p
+};