@oslokommune/punkt-react 11.18.0 → 11.19.0

package/dist/graphql-cb8e2feb.js

@@ -1,155 +0,0 @@
-import { g as Z } from "./index-9498f0f6.js";
-function $(i, s) {
-  for (var p = 0; p < s.length; p++) {
-    const n = s[p];
-    if (typeof n != "string" && !Array.isArray(n)) {
-      for (const a in n)
-        if (a !== "default" && !(a in i)) {
-          const t = Object.getOwnPropertyDescriptor(n, a);
-          t && Object.defineProperty(i, a, t.get ? t : {
-            enumerable: !0,
-            get: () => n[a]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(i, Symbol.toStringTag, { value: "Module" }));
-}
-var h, k;
-function j() {
-  if (k)
-    return h;
-  k = 1, h = i, i.displayName = "graphql", i.aliases = [];
-  function i(s) {
-    s.languages.graphql = {
-      comment: /#.*/,
-      description: {
-        pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
-        greedy: !0,
-        alias: "string",
-        inside: {
-          "language-markdown": {
-            pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
-            lookbehind: !0,
-            inside: s.languages.markdown
-          }
-        }
-      },
-      string: {
-        pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
-        greedy: !0
-      },
-      number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
-      boolean: /\b(?:false|true)\b/,
-      variable: /\$[a-z_]\w*/i,
-      directive: {
-        pattern: /@[a-z_]\w*/i,
-        alias: "function"
-      },
-      "attr-name": {
-        pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
-        greedy: !0
-      },
-      "atom-input": {
-        pattern: /\b[A-Z]\w*Input\b/,
-        alias: "class-name"
-      },
-      scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
-      constant: /\b[A-Z][A-Z_\d]*\b/,
-      "class-name": {
-        pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
-        lookbehind: !0
-      },
-      fragment: {
-        pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "definition-mutation": {
-        pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      "definition-query": {
-        pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
-        lookbehind: !0,
-        alias: "function"
-      },
-      keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
-      operator: /[!=|&]|\.{3}/,
-      "property-query": /\w+(?=\s*\()/,
-      object: /\w+(?=\s*\{)/,
-      punctuation: /[!(){}\[\]:=,]/,
-      property: /\w+/
-    }, s.hooks.add("after-tokenize", function(n) {
-      if (n.language !== "graphql")
-        return;
-      var a = n.tokens.filter(function(r) {
-        return typeof r != "string" && r.type !== "comment" && r.type !== "scalar";
-      }), t = 0;
-      function l(r) {
-        return a[t + r];
-      }
-      function v(r, o) {
-        o = o || 0;
-        for (var e = 0; e < r.length; e++) {
-          var u = l(e + o);
-          if (!u || u.type !== r[e])
-            return !1;
-        }
-        return !0;
-      }
-      function q(r, o) {
-        for (var e = 1, u = t; u < a.length; u++) {
-          var A = a[u], m = A.content;
-          if (A.type === "punctuation" && typeof m == "string") {
-            if (r.test(m))
-              e++;
-            else if (o.test(m) && (e--, e === 0))
-              return u;
-          }
-        }
-        return -1;
-      }
-      function f(r, o) {
-        var e = r.alias;
-        e ? Array.isArray(e) || (r.alias = e = [e]) : r.alias = e = [], e.push(o);
-      }
-      for (; t < a.length; ) {
-        var w = a[t++];
-        if (w.type === "keyword" && w.content === "mutation") {
-          var c = [];
-          if (v(["definition-mutation", "punctuation"]) && l(1).content === "(") {
-            t += 2;
-            var g = q(/^\($/, /^\)$/);
-            if (g === -1)
-              continue;
-            for (; t < g; t++) {
-              var b = l(0);
-              b.type === "variable" && (f(b, "variable-input"), c.push(b.content));
-            }
-            t = g + 1;
-          }
-          if (v(["punctuation", "property-query"]) && l(0).content === "{" && (t++, f(l(0), "property-mutation"), c.length > 0)) {
-            var _ = q(/^\{$/, /^\}$/);
-            if (_ === -1)
-              continue;
-            for (var d = t; d < _; d++) {
-              var y = a[d];
-              y.type === "variable" && c.indexOf(y.content) >= 0 && f(y, "variable-input");
-            }
-          }
-        }
-      }
-    });
-  }
-  return h;
-}
-var z = j();
-const x = /* @__PURE__ */ Z(z), I = /* @__PURE__ */ $({
-  __proto__: null,
-  default: x
-}, [z]);
-export {
-  I as g
-};

package/dist/groovy-ebb15fa5.js

@@ -1,83 +0,0 @@
-import { g as u } from "./index-9498f0f6.js";
-function c(n, t) {
-  for (var e = 0; e < t.length; e++) {
-    const o = t[e];
-    if (typeof o != "string" && !Array.isArray(o)) {
-      for (const r in o)
-        if (r !== "default" && !(r in n)) {
-          const a = Object.getOwnPropertyDescriptor(o, r);
-          a && Object.defineProperty(n, r, a.get ? a : {
-            enumerable: !0,
-            get: () => o[r]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
-}
-var i, s;
-function l() {
-  if (s)
-    return i;
-  s = 1, i = n, n.displayName = "groovy", n.aliases = [];
-  function n(t) {
-    t.languages.groovy = t.languages.extend("clike", {
-      string: [
-        {
-          // https://groovy-lang.org/syntax.html#_dollar_slashy_string
-          pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
-          greedy: !0
-        },
-        {
-          // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
-          // simple division (see JS regex), so find a fix maybe?
-          pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-          greedy: !0
-        }
-      ],
-      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
-      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
-      operator: {
-        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
-        lookbehind: !0
-      },
-      punctuation: /\.+|[{}[\];(),:$]/
-    }), t.languages.insertBefore("groovy", "string", {
-      shebang: {
-        pattern: /#!.+/,
-        alias: "comment"
-      }
-    }), t.languages.insertBefore("groovy", "punctuation", {
-      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
-    }), t.languages.insertBefore("groovy", "function", {
-      annotation: {
-        pattern: /(^|[^.])@\w+/,
-        lookbehind: !0,
-        alias: "punctuation"
-      }
-    }), t.hooks.add("wrap", function(e) {
-      if (e.language === "groovy" && e.type === "string") {
-        var o = e.content.value[0];
-        if (o != "'") {
-          var r = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
-          o === "$" && (r = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/), e.content.value = e.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&"), e.content = t.highlight(e.content.value, {
-            expression: {
-              pattern: r,
-              lookbehind: !0,
-              inside: t.languages.groovy
-            }
-          }), e.classes.push(o === "/" ? "regex" : "gstring");
-        }
-      }
-    });
-  }
-  return i;
-}
-var g = l();
-const p = /* @__PURE__ */ u(g), d = /* @__PURE__ */ c({
-  __proto__: null,
-  default: p
-}, [g]);
-export {
-  d as g
-};

package/dist/haml-65978a94.js

@@ -1,173 +0,0 @@
-import { g as c } from "./index-9498f0f6.js";
-import { r as f } from "./ruby-90470291.js";
-function b(l, n) {
-  for (var a = 0; a < n.length; a++) {
-    const e = n[a];
-    if (typeof e != "string" && !Array.isArray(e)) {
-      for (const r in e)
-        if (r !== "default" && !(r in l)) {
-          const i = Object.getOwnPropertyDescriptor(e, r);
-          i && Object.defineProperty(l, r, i.get ? i : {
-            enumerable: !0,
-            get: () => e[r]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(l, Symbol.toStringTag, { value: "Module" }));
-}
-var u, g;
-function m() {
-  if (g)
-    return u;
-  g = 1;
-  var l = f();
-  u = n, n.displayName = "haml", n.aliases = [];
-  function n(a) {
-    a.register(l), function(e) {
-      e.languages.haml = {
-        // Multiline stuff should appear before the rest
-        "multiline-comment": {
-          pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
-          lookbehind: !0,
-          alias: "comment"
-        },
-        "multiline-code": [
-          {
-            pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
-            lookbehind: !0,
-            inside: e.languages.ruby
-          },
-          {
-            pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
-            lookbehind: !0,
-            inside: e.languages.ruby
-          }
-        ],
-        // See at the end of the file for known filters
-        filter: {
-          pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
-          lookbehind: !0,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "symbol"
-            }
-          }
-        },
-        markup: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
-          lookbehind: !0,
-          inside: e.languages.markup
-        },
-        doctype: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
-          lookbehind: !0
-        },
-        tag: {
-          // Allows for one nested group of braces
-          pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
-          lookbehind: !0,
-          inside: {
-            attributes: [
-              {
-                // Lookbehind tries to prevent interpolations from breaking it all
-                // Allows for one nested group of braces
-                pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
-                lookbehind: !0,
-                inside: e.languages.ruby
-              },
-              {
-                pattern: /\([^)]+\)/,
-                inside: {
-                  "attr-value": {
-                    pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
-                    lookbehind: !0
-                  },
-                  "attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
-                  punctuation: /[=(),]/
-                }
-              },
-              {
-                pattern: /\[[^\]]+\]/,
-                inside: e.languages.ruby
-              }
-            ],
-            punctuation: /[<>]/
-          }
-        },
-        code: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
-          lookbehind: !0,
-          inside: e.languages.ruby
-        },
-        // Interpolations in plain text
-        interpolation: {
-          pattern: /#\{[^}]+\}/,
-          inside: {
-            delimiter: {
-              pattern: /^#\{|\}$/,
-              alias: "punctuation"
-            },
-            ruby: {
-              pattern: /[\s\S]+/,
-              inside: e.languages.ruby
-            }
-          }
-        },
-        punctuation: {
-          pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
-          lookbehind: !0
-        }
-      };
-      for (var r = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+", i = [
-        "css",
-        {
-          filter: "coffee",
-          language: "coffeescript"
-        },
-        "erb",
-        "javascript",
-        "less",
-        "markdown",
-        "ruby",
-        "scss",
-        "textile"
-      ], s = {}, o = 0, d = i.length; o < d; o++) {
-        var t = i[o];
-        t = typeof t == "string" ? {
-          filter: t,
-          language: t
-        } : t, e.languages[t.language] && (s["filter-" + t.filter] = {
-          pattern: RegExp(
-            r.replace("{{filter_name}}", function() {
-              return t.filter;
-            })
-          ),
-          lookbehind: !0,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "symbol"
-            },
-            text: {
-              pattern: /[\s\S]+/,
-              alias: [t.language, "language-" + t.language],
-              inside: e.languages[t.language]
-            }
-          }
-        });
-      }
-      e.languages.insertBefore("haml", "filter", s);
-    }(a);
-  }
-  return u;
-}
-var p = m();
-const h = /* @__PURE__ */ c(p), v = /* @__PURE__ */ b({
-  __proto__: null,
-  default: h
-}, [p]);
-export {
-  v as h
-};

package/dist/handlebars-50594839.js

@@ -1,75 +0,0 @@
-import { g as i } from "./index-9498f0f6.js";
-import { r as d } from "./markup-templating-49c15a5f.js";
-function b(n, r) {
-  for (var t = 0; t < r.length; t++) {
-    const e = r[t];
-    if (typeof e != "string" && !Array.isArray(e)) {
-      for (const a in e)
-        if (a !== "default" && !(a in n)) {
-          const s = Object.getOwnPropertyDescriptor(e, a);
-          s && Object.defineProperty(n, a, s.get ? s : {
-            enumerable: !0,
-            get: () => e[a]
-          });
-        }
-    }
-  }
-  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
-}
-var o, l;
-function g() {
-  if (l)
-    return o;
-  l = 1;
-  var n = d();
-  o = r, r.displayName = "handlebars", r.aliases = ["hbs"];
-  function r(t) {
-    t.register(n), function(e) {
-      e.languages.handlebars = {
-        comment: /\{\{![\s\S]*?\}\}/,
-        delimiter: {
-          pattern: /^\{\{\{?|\}\}\}?$/,
-          alias: "punctuation"
-        },
-        string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-        number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
-        boolean: /\b(?:false|true)\b/,
-        block: {
-          pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
-          lookbehind: !0,
-          alias: "keyword"
-        },
-        brackets: {
-          pattern: /\[[^\]]+\]/,
-          inside: {
-            punctuation: /\[|\]/,
-            variable: /[\s\S]+/
-          }
-        },
-        punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
-        variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
-      }, e.hooks.add("before-tokenize", function(a) {
-        var s = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
-        e.languages["markup-templating"].buildPlaceholders(
-          a,
-          "handlebars",
-          s
-        );
-      }), e.hooks.add("after-tokenize", function(a) {
-        e.languages["markup-templating"].tokenizePlaceholders(
-          a,
-          "handlebars"
-        );
-      }), e.languages.hbs = e.languages.handlebars;
-    }(t);
-  }
-  return o;
-}
-var u = g();
-const p = /* @__PURE__ */ i(u), h = /* @__PURE__ */ b({
-  __proto__: null,
-  default: p
-}, [u]);
-export {
-  h
-};

package/dist/haskell-5775a4fe.js

@@ -1,76 +0,0 @@
-var t, i;
-function r() {
-  if (i)
-    return t;
-  i = 1, t = e, e.displayName = "haskell", e.aliases = ["hs"];
-  function e(a) {
-    a.languages.haskell = {
-      comment: {
-        pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
-        lookbehind: !0
-      },
-      char: {
-        pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
-        alias: "string"
-      },
-      string: {
-        pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
-        greedy: !0
-      },
-      keyword: /\b(?:case|class|data|deriving|do|else|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+(?:qualified\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|qualified)\b/,
-          punctuation: /\./
-        }
-      },
-      // These are builtin variables only. Constructors are highlighted later as a constant.
-      builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
-      // decimal integers and floating point numbers | octal integers | hexadecimal integers
-      number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
-      operator: [
-        {
-          // infix operator
-          pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
-          greedy: !0
-        },
-        {
-          // function composition
-          pattern: /(\s)\.(?=\s)/,
-          lookbehind: !0
-        },
-        // Most of this is needed because of the meaning of a single '.'.
-        // If it stands alone freely, it is the function composition.
-        // It may also be a separator between a module name and an identifier => no
-        // operator. If it comes together with other special characters it is an
-        // operator too.
-        //
-        // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
-        /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
-      ],
-      // In Haskell, nearly everything is a variable, do not highlight these.
-      hvariable: {
-        pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
-        inside: {
-          punctuation: /\./
-        }
-      },
-      constant: {
-        pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
-        inside: {
-          punctuation: /\./
-        }
-      },
-      punctuation: /[{}[\];(),.:]/
-    }, a.languages.hs = a.languages.haskell;
-  }
-  return t;
-}
-export {
-  r
-};

package/dist/haskell-ab4dc776.js

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