@oslokommune/punkt-react 11.18.0 → 11.19.0

package/dist/pug-f3c562dd.js

@@ -1,213 +0,0 @@
-import { g as c } from "./index-9498f0f6.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-396c5218.js

@@ -1,168 +0,0 @@
-import { g as s } from "./index-9498f0f6.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-9cf5d182.js

@@ -1,112 +0,0 @@
-import { g as u } from "./index-9498f0f6.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-02478411.js

@@ -1,88 +0,0 @@
-import { g as s } from "./index-9498f0f6.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-cf2309c0.js

@@ -1,63 +0,0 @@
-import { g as d } from "./index-9498f0f6.js";
-import { r as n } from "./haskell-5775a4fe.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
-};