storybook 10.1.0-alpha.12 → 10.1.0-alpha.14

package/dist/_node-chunks/{chunk-5HV3B5OP.js → chunk-63PL4NNE.js}

@@ -1,30 +1,26 @@
-import CJS_COMPAT_NODE_URL_57ru1wfqqjv from 'node:url';
-import CJS_COMPAT_NODE_PATH_57ru1wfqqjv from 'node:path';
-import CJS_COMPAT_NODE_MODULE_57ru1wfqqjv from "node:module";
+import CJS_COMPAT_NODE_URL_yntchggdu3k from 'node:url';
+import CJS_COMPAT_NODE_PATH_yntchggdu3k from 'node:path';
+import CJS_COMPAT_NODE_MODULE_yntchggdu3k from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_57ru1wfqqjv.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_57ru1wfqqjv.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_57ru1wfqqjv.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_yntchggdu3k.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_yntchggdu3k.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_yntchggdu3k.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
-import {
-  require_gen_mapping_umd,
-  require_trace_mapping_umd
-} from "./chunk-FDXFVHIL.js";
 import {
   require_lib,
   require_src
-} from "./chunk-FZLRAH4N.js";
+} from "./chunk-2JR3QBT2.js";
 import {
   require_picocolors
-} from "./chunk-NAOYEL54.js";
+} from "./chunk-A4KENTXT.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-OP3INKUD.js";
+} from "./chunk-JMP7YFX2.js";
 
 // ../node_modules/@babel/types/lib/utils/shallowEqual.js
 var require_shallowEqual = __commonJS({
@@ -24656,6 +24652,1101 @@ var require_scope = __commonJS({
   }
 });
 
+// ../node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
+var require_sourcemap_codec_umd = __commonJS({
+  "../node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js"(exports, module) {
+    (function(global2, factory) {
+      if (typeof exports == "object" && typeof module < "u")
+        factory(module), module.exports = def(module);
+      else if (typeof define == "function" && define.amd)
+        define(["module"], function(mod) {
+          factory.apply(this, arguments), mod.exports = def(mod);
+        });
+      else {
+        let mod = { exports: {} };
+        factory(mod), global2 = typeof globalThis < "u" ? globalThis : global2 || self, global2.sourcemapCodec = def(mod);
+      }
+      function def(m) {
+        return "default" in m.exports ? m.exports.default : m.exports;
+      }
+    })(exports, (function(module2) {
+      "use strict";
+      var __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __hasOwnProp = Object.prototype.hasOwnProperty, __export = (target, all) => {
+        for (var name in all)
+          __defProp(target, name, { get: all[name], enumerable: !0 });
+      }, __copyProps = (to, from, except, desc) => {
+        if (from && typeof from == "object" || typeof from == "function")
+          for (let key of __getOwnPropNames(from))
+            !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        return to;
+      }, __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), sourcemap_codec_exports = {};
+      __export(sourcemap_codec_exports, {
+        decode: () => decode,
+        decodeGeneratedRanges: () => decodeGeneratedRanges,
+        decodeOriginalScopes: () => decodeOriginalScopes,
+        encode: () => encode,
+        encodeGeneratedRanges: () => encodeGeneratedRanges,
+        encodeOriginalScopes: () => encodeOriginalScopes
+      }), module2.exports = __toCommonJS(sourcemap_codec_exports);
+      var comma = 44, semicolon = 59, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", intToChar = new Uint8Array(64), charToInt = new Uint8Array(128);
+      for (let i = 0; i < chars.length; i++) {
+        let c = chars.charCodeAt(i);
+        intToChar[i] = c, charToInt[c] = i;
+      }
+      function decodeInteger(reader, relative) {
+        let value2 = 0, shift = 0, integer = 0;
+        do {
+          let c = reader.next();
+          integer = charToInt[c], value2 |= (integer & 31) << shift, shift += 5;
+        } while (integer & 32);
+        let shouldNegate = value2 & 1;
+        return value2 >>>= 1, shouldNegate && (value2 = -2147483648 | -value2), relative + value2;
+      }
+      function encodeInteger(builder, num, relative) {
+        let delta = num - relative;
+        delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
+        do {
+          let clamped = delta & 31;
+          delta >>>= 5, delta > 0 && (clamped |= 32), builder.write(intToChar[clamped]);
+        } while (delta > 0);
+        return num;
+      }
+      function hasMoreVlq(reader, max) {
+        return reader.pos >= max ? !1 : reader.peek() !== comma;
+      }
+      var bufLength = 1024 * 16, td = typeof TextDecoder < "u" ? new TextDecoder() : typeof Buffer < "u" ? {
+        decode(buf) {
+          return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+        }
+      } : {
+        decode(buf) {
+          let out = "";
+          for (let i = 0; i < buf.length; i++)
+            out += String.fromCharCode(buf[i]);
+          return out;
+        }
+      }, StringWriter = class {
+        constructor() {
+          this.pos = 0, this.out = "", this.buffer = new Uint8Array(bufLength);
+        }
+        write(v) {
+          let { buffer } = this;
+          buffer[this.pos++] = v, this.pos === bufLength && (this.out += td.decode(buffer), this.pos = 0);
+        }
+        flush() {
+          let { buffer, out, pos } = this;
+          return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+        }
+      }, StringReader = class {
+        constructor(buffer) {
+          this.pos = 0, this.buffer = buffer;
+        }
+        next() {
+          return this.buffer.charCodeAt(this.pos++);
+        }
+        peek() {
+          return this.buffer.charCodeAt(this.pos);
+        }
+        indexOf(char) {
+          let { buffer, pos } = this, idx = buffer.indexOf(char, pos);
+          return idx === -1 ? buffer.length : idx;
+        }
+      }, EMPTY = [];
+      function decodeOriginalScopes(input) {
+        let { length } = input, reader = new StringReader(input), scopes = [], stack = [], line = 0;
+        for (; reader.pos < length; reader.pos++) {
+          line = decodeInteger(reader, line);
+          let column = decodeInteger(reader, 0);
+          if (!hasMoreVlq(reader, length)) {
+            let last = stack.pop();
+            last[2] = line, last[3] = column;
+            continue;
+          }
+          let kind = decodeInteger(reader, 0), scope = decodeInteger(reader, 0) & 1 ? [line, column, 0, 0, kind, decodeInteger(reader, 0)] : [line, column, 0, 0, kind], vars = EMPTY;
+          if (hasMoreVlq(reader, length)) {
+            vars = [];
+            do {
+              let varsIndex = decodeInteger(reader, 0);
+              vars.push(varsIndex);
+            } while (hasMoreVlq(reader, length));
+          }
+          scope.vars = vars, scopes.push(scope), stack.push(scope);
+        }
+        return scopes;
+      }
+      function encodeOriginalScopes(scopes) {
+        let writer = new StringWriter();
+        for (let i = 0; i < scopes.length; )
+          i = _encodeOriginalScopes(scopes, i, writer, [0]);
+        return writer.flush();
+      }
+      function _encodeOriginalScopes(scopes, index, writer, state) {
+        let scope = scopes[index], { 0: startLine, 1: startColumn, 2: endLine, 3: endColumn, 4: kind, vars } = scope;
+        index > 0 && writer.write(comma), state[0] = encodeInteger(writer, startLine, state[0]), encodeInteger(writer, startColumn, 0), encodeInteger(writer, kind, 0);
+        let fields = scope.length === 6 ? 1 : 0;
+        encodeInteger(writer, fields, 0), scope.length === 6 && encodeInteger(writer, scope[5], 0);
+        for (let v of vars)
+          encodeInteger(writer, v, 0);
+        for (index++; index < scopes.length; ) {
+          let next = scopes[index], { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn)
+            break;
+          index = _encodeOriginalScopes(scopes, index, writer, state);
+        }
+        return writer.write(comma), state[0] = encodeInteger(writer, endLine, state[0]), encodeInteger(writer, endColumn, 0), index;
+      }
+      function decodeGeneratedRanges(input) {
+        let { length } = input, reader = new StringReader(input), ranges = [], stack = [], genLine = 0, definitionSourcesIndex = 0, definitionScopeIndex = 0, callsiteSourcesIndex = 0, callsiteLine = 0, callsiteColumn = 0, bindingLine = 0, bindingColumn = 0;
+        do {
+          let semi = reader.indexOf(";"), genColumn = 0;
+          for (; reader.pos < semi; reader.pos++) {
+            if (genColumn = decodeInteger(reader, genColumn), !hasMoreVlq(reader, semi)) {
+              let last = stack.pop();
+              last[2] = genLine, last[3] = genColumn;
+              continue;
+            }
+            let fields = decodeInteger(reader, 0), hasDefinition = fields & 1, hasCallsite = fields & 2, hasScope = fields & 4, callsite = null, bindings = EMPTY, range;
+            if (hasDefinition) {
+              let defSourcesIndex = decodeInteger(reader, definitionSourcesIndex);
+              definitionScopeIndex = decodeInteger(
+                reader,
+                definitionSourcesIndex === defSourcesIndex ? definitionScopeIndex : 0
+              ), definitionSourcesIndex = defSourcesIndex, range = [genLine, genColumn, 0, 0, defSourcesIndex, definitionScopeIndex];
+            } else
+              range = [genLine, genColumn, 0, 0];
+            if (range.isScope = !!hasScope, hasCallsite) {
+              let prevCsi = callsiteSourcesIndex, prevLine = callsiteLine;
+              callsiteSourcesIndex = decodeInteger(reader, callsiteSourcesIndex);
+              let sameSource = prevCsi === callsiteSourcesIndex;
+              callsiteLine = decodeInteger(reader, sameSource ? callsiteLine : 0), callsiteColumn = decodeInteger(
+                reader,
+                sameSource && prevLine === callsiteLine ? callsiteColumn : 0
+              ), callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+            }
+            if (range.callsite = callsite, hasMoreVlq(reader, semi)) {
+              bindings = [];
+              do {
+                bindingLine = genLine, bindingColumn = genColumn;
+                let expressionsCount = decodeInteger(reader, 0), expressionRanges;
+                if (expressionsCount < -1) {
+                  expressionRanges = [[decodeInteger(reader, 0)]];
+                  for (let i = -1; i > expressionsCount; i--) {
+                    let prevBl = bindingLine;
+                    bindingLine = decodeInteger(reader, bindingLine), bindingColumn = decodeInteger(reader, bindingLine === prevBl ? bindingColumn : 0);
+                    let expression = decodeInteger(reader, 0);
+                    expressionRanges.push([expression, bindingLine, bindingColumn]);
+                  }
+                } else
+                  expressionRanges = [[expressionsCount]];
+                bindings.push(expressionRanges);
+              } while (hasMoreVlq(reader, semi));
+            }
+            range.bindings = bindings, ranges.push(range), stack.push(range);
+          }
+          genLine++, reader.pos = semi + 1;
+        } while (reader.pos < length);
+        return ranges;
+      }
+      function encodeGeneratedRanges(ranges) {
+        if (ranges.length === 0) return "";
+        let writer = new StringWriter();
+        for (let i = 0; i < ranges.length; )
+          i = _encodeGeneratedRanges(ranges, i, writer, [0, 0, 0, 0, 0, 0, 0]);
+        return writer.flush();
+      }
+      function _encodeGeneratedRanges(ranges, index, writer, state) {
+        let range = ranges[index], {
+          0: startLine,
+          1: startColumn,
+          2: endLine,
+          3: endColumn,
+          isScope,
+          callsite,
+          bindings
+        } = range;
+        state[0] < startLine ? (catchupLine(writer, state[0], startLine), state[0] = startLine, state[1] = 0) : index > 0 && writer.write(comma), state[1] = encodeInteger(writer, range[1], state[1]);
+        let fields = (range.length === 6 ? 1 : 0) | (callsite ? 2 : 0) | (isScope ? 4 : 0);
+        if (encodeInteger(writer, fields, 0), range.length === 6) {
+          let { 4: sourcesIndex, 5: scopesIndex } = range;
+          sourcesIndex !== state[2] && (state[3] = 0), state[2] = encodeInteger(writer, sourcesIndex, state[2]), state[3] = encodeInteger(writer, scopesIndex, state[3]);
+        }
+        if (callsite) {
+          let { 0: sourcesIndex, 1: callLine, 2: callColumn } = range.callsite;
+          sourcesIndex !== state[4] ? (state[5] = 0, state[6] = 0) : callLine !== state[5] && (state[6] = 0), state[4] = encodeInteger(writer, sourcesIndex, state[4]), state[5] = encodeInteger(writer, callLine, state[5]), state[6] = encodeInteger(writer, callColumn, state[6]);
+        }
+        if (bindings)
+          for (let binding of bindings) {
+            binding.length > 1 && encodeInteger(writer, -binding.length, 0);
+            let expression = binding[0][0];
+            encodeInteger(writer, expression, 0);
+            let bindingStartLine = startLine, bindingStartColumn = startColumn;
+            for (let i = 1; i < binding.length; i++) {
+              let expRange = binding[i];
+              bindingStartLine = encodeInteger(writer, expRange[1], bindingStartLine), bindingStartColumn = encodeInteger(writer, expRange[2], bindingStartColumn), encodeInteger(writer, expRange[0], 0);
+            }
+          }
+        for (index++; index < ranges.length; ) {
+          let next = ranges[index], { 0: l, 1: c } = next;
+          if (l > endLine || l === endLine && c >= endColumn)
+            break;
+          index = _encodeGeneratedRanges(ranges, index, writer, state);
+        }
+        return state[0] < endLine ? (catchupLine(writer, state[0], endLine), state[0] = endLine, state[1] = 0) : writer.write(comma), state[1] = encodeInteger(writer, endColumn, state[1]), index;
+      }
+      function catchupLine(writer, lastLine, line) {
+        do
+          writer.write(semicolon);
+        while (++lastLine < line);
+      }
+      function decode(mappings) {
+        let { length } = mappings, reader = new StringReader(mappings), decoded = [], genColumn = 0, sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+        do {
+          let semi = reader.indexOf(";"), line = [], sorted = !0, lastCol = 0;
+          for (genColumn = 0; reader.pos < semi; ) {
+            let seg;
+            genColumn = decodeInteger(reader, genColumn), genColumn < lastCol && (sorted = !1), lastCol = genColumn, hasMoreVlq(reader, semi) ? (sourcesIndex = decodeInteger(reader, sourcesIndex), sourceLine = decodeInteger(reader, sourceLine), sourceColumn = decodeInteger(reader, sourceColumn), hasMoreVlq(reader, semi) ? (namesIndex = decodeInteger(reader, namesIndex), seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]) : seg = [genColumn, sourcesIndex, sourceLine, sourceColumn]) : seg = [genColumn], line.push(seg), reader.pos++;
+          }
+          sorted || sort(line), decoded.push(line), reader.pos = semi + 1;
+        } while (reader.pos <= length);
+        return decoded;
+      }
+      function sort(line) {
+        line.sort(sortComparator);
+      }
+      function sortComparator(a, b) {
+        return a[0] - b[0];
+      }
+      function encode(decoded) {
+        let writer = new StringWriter(), sourcesIndex = 0, sourceLine = 0, sourceColumn = 0, namesIndex = 0;
+        for (let i = 0; i < decoded.length; i++) {
+          let line = decoded[i];
+          if (i > 0 && writer.write(semicolon), line.length === 0) continue;
+          let genColumn = 0;
+          for (let j = 0; j < line.length; j++) {
+            let segment = line[j];
+            j > 0 && writer.write(comma), genColumn = encodeInteger(writer, segment[0], genColumn), segment.length !== 1 && (sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex), sourceLine = encodeInteger(writer, segment[2], sourceLine), sourceColumn = encodeInteger(writer, segment[3], sourceColumn), segment.length !== 4 && (namesIndex = encodeInteger(writer, segment[4], namesIndex)));
+          }
+        }
+        return writer.flush();
+      }
+    }));
+  }
+});
+
+// ../node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
+var require_resolve_uri_umd = __commonJS({
+  "../node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js"(exports, module) {
+    (function(global2, factory) {
+      typeof exports == "object" && typeof module < "u" ? module.exports = factory() : typeof define == "function" && define.amd ? define(factory) : (global2 = typeof globalThis < "u" ? globalThis : global2 || self, global2.resolveURI = factory());
+    })(exports, (function() {
+      "use strict";
+      let schemeRegex = /^[\w+.-]+:\/\//, urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/, fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+      function isAbsoluteUrl(input) {
+        return schemeRegex.test(input);
+      }
+      function isSchemeRelativeUrl(input) {
+        return input.startsWith("//");
+      }
+      function isAbsolutePath(input) {
+        return input.startsWith("/");
+      }
+      function isFileUrl(input) {
+        return input.startsWith("file:");
+      }
+      function isRelative(input) {
+        return /^[.?#]/.test(input);
+      }
+      function parseAbsoluteUrl(input) {
+        let match = urlRegex.exec(input);
+        return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+      }
+      function parseFileUrl(input) {
+        let match = fileRegex.exec(input), path = match[2];
+        return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+      }
+      function makeUrl(scheme, user, host, port, path, query, hash) {
+        return {
+          scheme,
+          user,
+          host,
+          port,
+          path,
+          query,
+          hash,
+          type: 7
+        };
+      }
+      function parseUrl(input) {
+        if (isSchemeRelativeUrl(input)) {
+          let url2 = parseAbsoluteUrl("http:" + input);
+          return url2.scheme = "", url2.type = 6, url2;
+        }
+        if (isAbsolutePath(input)) {
+          let url2 = parseAbsoluteUrl("http://foo.com" + input);
+          return url2.scheme = "", url2.host = "", url2.type = 5, url2;
+        }
+        if (isFileUrl(input))
+          return parseFileUrl(input);
+        if (isAbsoluteUrl(input))
+          return parseAbsoluteUrl(input);
+        let url = parseAbsoluteUrl("http://foo.com/" + input);
+        return url.scheme = "", url.host = "", url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1, url;
+      }
+      function stripPathFilename(path) {
+        if (path.endsWith("/.."))
+          return path;
+        let index = path.lastIndexOf("/");
+        return path.slice(0, index + 1);
+      }
+      function mergePaths(url, base) {
+        normalizePath(base, base.type), url.path === "/" ? url.path = base.path : url.path = stripPathFilename(base.path) + url.path;
+      }
+      function normalizePath(url, type) {
+        let rel = type <= 4, pieces = url.path.split("/"), pointer = 1, positive = 0, addTrailingSlash = !1;
+        for (let i = 1; i < pieces.length; i++) {
+          let piece = pieces[i];
+          if (!piece) {
+            addTrailingSlash = !0;
+            continue;
+          }
+          if (addTrailingSlash = !1, piece !== ".") {
+            if (piece === "..") {
+              positive ? (addTrailingSlash = !0, positive--, pointer--) : rel && (pieces[pointer++] = piece);
+              continue;
+            }
+            pieces[pointer++] = piece, positive++;
+          }
+        }
+        let path = "";
+        for (let i = 1; i < pointer; i++)
+          path += "/" + pieces[i];
+        (!path || addTrailingSlash && !path.endsWith("/..")) && (path += "/"), url.path = path;
+      }
+      function resolve(input, base) {
+        if (!input && !base)
+          return "";
+        let url = parseUrl(input), inputType = url.type;
+        if (base && inputType !== 7) {
+          let baseUrl = parseUrl(base), baseType = baseUrl.type;
+          switch (inputType) {
+            case 1:
+              url.hash = baseUrl.hash;
+            // fall through
+            case 2:
+              url.query = baseUrl.query;
+            // fall through
+            case 3:
+            case 4:
+              mergePaths(url, baseUrl);
+            // fall through
+            case 5:
+              url.user = baseUrl.user, url.host = baseUrl.host, url.port = baseUrl.port;
+            // fall through
+            case 6:
+              url.scheme = baseUrl.scheme;
+          }
+          baseType > inputType && (inputType = baseType);
+        }
+        normalizePath(url, inputType);
+        let queryHash = url.query + url.hash;
+        switch (inputType) {
+          // This is impossible, because of the empty checks at the start of the function.
+          // case UrlType.Empty:
+          case 2:
+          case 3:
+            return queryHash;
+          case 4: {
+            let path = url.path.slice(1);
+            return path ? isRelative(base || input) && !isRelative(path) ? "./" + path + queryHash : path + queryHash : queryHash || ".";
+          }
+          case 5:
+            return url.path + queryHash;
+          default:
+            return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+        }
+      }
+      return resolve;
+    }));
+  }
+});
+
+// ../node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
+var require_trace_mapping_umd = __commonJS({
+  "../node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js"(exports, module) {
+    (function(global2, factory) {
+      if (typeof exports == "object" && typeof module < "u")
+        factory(module, require_resolve_uri_umd(), require_sourcemap_codec_umd()), module.exports = def(module);
+      else if (typeof define == "function" && define.amd)
+        define(["module", "@jridgewell/resolve-uri", "@jridgewell/sourcemap-codec"], function(mod) {
+          factory.apply(this, arguments), mod.exports = def(mod);
+        });
+      else {
+        let mod = { exports: {} };
+        factory(mod, global2.resolveURI, global2.sourcemapCodec), global2 = typeof globalThis < "u" ? globalThis : global2 || self, global2.traceMapping = def(mod);
+      }
+      function def(m) {
+        return "default" in m.exports ? m.exports.default : m.exports;
+      }
+    })(exports, (function(module2, require_resolveURI, require_sourcemapCodec) {
+      "use strict";
+      var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJS2 = (cb, mod) => function() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+      }, __export = (target, all) => {
+        for (var name in all)
+          __defProp(target, name, { get: all[name], enumerable: !0 });
+      }, __copyProps = (to, from, except, desc) => {
+        if (from && typeof from == "object" || typeof from == "function")
+          for (let key of __getOwnPropNames(from))
+            !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        return to;
+      }, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+        // If the importer is in node compatibility mode or this is not an ESM
+        // file that has been converted to a CommonJS file using a Babel-
+        // compatible transform (i.e. "__esModule" has not been set), then set
+        // "default" to the CommonJS "module.exports" for node compatibility.
+        isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+        mod
+      )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), require_sourcemap_codec = __commonJS2({
+        "umd:@jridgewell/sourcemap-codec"(exports2, module22) {
+          module22.exports = require_sourcemapCodec;
+        }
+      }), require_resolve_uri = __commonJS2({
+        "umd:@jridgewell/resolve-uri"(exports2, module22) {
+          module22.exports = require_resolveURI;
+        }
+      }), trace_mapping_exports = {};
+      __export(trace_mapping_exports, {
+        AnyMap: () => FlattenMap,
+        FlattenMap: () => FlattenMap,
+        GREATEST_LOWER_BOUND: () => GREATEST_LOWER_BOUND,
+        LEAST_UPPER_BOUND: () => LEAST_UPPER_BOUND,
+        TraceMap: () => TraceMap,
+        allGeneratedPositionsFor: () => allGeneratedPositionsFor,
+        decodedMap: () => decodedMap,
+        decodedMappings: () => decodedMappings,
+        eachMapping: () => eachMapping,
+        encodedMap: () => encodedMap,
+        encodedMappings: () => encodedMappings,
+        generatedPositionFor: () => generatedPositionFor,
+        isIgnored: () => isIgnored,
+        originalPositionFor: () => originalPositionFor,
+        presortedDecodedMap: () => presortedDecodedMap,
+        sourceContentFor: () => sourceContentFor,
+        traceSegment: () => traceSegment
+      }), module2.exports = __toCommonJS(trace_mapping_exports);
+      var import_sourcemap_codec = __toESM2(require_sourcemap_codec()), import_resolve_uri = __toESM2(require_resolve_uri());
+      function stripFilename(path) {
+        if (!path) return "";
+        let index = path.lastIndexOf("/");
+        return path.slice(0, index + 1);
+      }
+      function resolver(mapUrl, sourceRoot) {
+        let from = stripFilename(mapUrl), prefix = sourceRoot ? sourceRoot + "/" : "";
+        return (source) => (0, import_resolve_uri.default)(prefix + (source || ""), from);
+      }
+      var COLUMN = 0, SOURCES_INDEX = 1, SOURCE_LINE = 2, SOURCE_COLUMN = 3, NAMES_INDEX = 4, REV_GENERATED_LINE = 1, REV_GENERATED_COLUMN = 2;
+      function maybeSort(mappings, owned) {
+        let unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+        if (unsortedIndex === mappings.length) return mappings;
+        owned || (mappings = mappings.slice());
+        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1))
+          mappings[i] = sortSegments(mappings[i], owned);
+        return mappings;
+      }
+      function nextUnsortedSegmentLine(mappings, start) {
+        for (let i = start; i < mappings.length; i++)
+          if (!isSorted(mappings[i])) return i;
+        return mappings.length;
+      }
+      function isSorted(line) {
+        for (let j = 1; j < line.length; j++)
+          if (line[j][COLUMN] < line[j - 1][COLUMN])
+            return !1;
+        return !0;
+      }
+      function sortSegments(line, owned) {
+        return owned || (line = line.slice()), line.sort(sortComparator);
+      }
+      function sortComparator(a, b) {
+        return a[COLUMN] - b[COLUMN];
+      }
+      function buildBySources(decoded, memos) {
+        let sources = memos.map(() => []);
+        for (let i = 0; i < decoded.length; i++) {
+          let line = decoded[i];
+          for (let j = 0; j < line.length; j++) {
+            let seg = line[j];
+            if (seg.length === 1) continue;
+            let sourceIndex2 = seg[SOURCES_INDEX], sourceLine = seg[SOURCE_LINE], sourceColumn = seg[SOURCE_COLUMN], source = sources[sourceIndex2];
+            (source[sourceLine] || (source[sourceLine] = [])).push([sourceColumn, i, seg[COLUMN]]);
+          }
+        }
+        for (let i = 0; i < sources.length; i++) {
+          let source = sources[i];
+          for (let j = 0; j < source.length; j++) {
+            let line = source[j];
+            line && line.sort(sortComparator);
+          }
+        }
+        return sources;
+      }
+      var found = !1;
+      function binarySearch(haystack, needle, low, high) {
+        for (; low <= high; ) {
+          let mid = low + (high - low >> 1), cmp = haystack[mid][COLUMN] - needle;
+          if (cmp === 0)
+            return found = !0, mid;
+          cmp < 0 ? low = mid + 1 : high = mid - 1;
+        }
+        return found = !1, low - 1;
+      }
+      function upperBound(haystack, needle, index) {
+        for (let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++)
+          ;
+        return index;
+      }
+      function lowerBound(haystack, needle, index) {
+        for (let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--)
+          ;
+        return index;
+      }
+      function memoizedState() {
+        return {
+          lastKey: -1,
+          lastNeedle: -1,
+          lastIndex: -1
+        };
+      }
+      function memoizedBinarySearch(haystack, needle, state, key) {
+        let { lastKey, lastNeedle, lastIndex } = state, low = 0, high = haystack.length - 1;
+        if (key === lastKey) {
+          if (needle === lastNeedle)
+            return found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle, lastIndex;
+          needle >= lastNeedle ? low = lastIndex === -1 ? 0 : lastIndex : high = lastIndex;
+        }
+        return state.lastKey = key, state.lastNeedle = needle, state.lastIndex = binarySearch(haystack, needle, low, high);
+      }
+      function parse3(map) {
+        return typeof map == "string" ? JSON.parse(map) : map;
+      }
+      var FlattenMap = function(map, mapUrl) {
+        let parsed = parse3(map);
+        if (!("sections" in parsed))
+          return new TraceMap(parsed, mapUrl);
+        let mappings = [], sources = [], sourcesContent = [], names = [], ignoreList = [];
+        recurse(
+          parsed,
+          mapUrl,
+          mappings,
+          sources,
+          sourcesContent,
+          names,
+          ignoreList,
+          0,
+          0,
+          1 / 0,
+          1 / 0
+        );
+        let joined = {
+          version: 3,
+          file: parsed.file,
+          names,
+          sources,
+          sourcesContent,
+          mappings,
+          ignoreList
+        };
+        return presortedDecodedMap(joined);
+      };
+      function recurse(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        let { sections } = input;
+        for (let i = 0; i < sections.length; i++) {
+          let { map, offset } = sections[i], sl = stopLine, sc = stopColumn;
+          if (i + 1 < sections.length) {
+            let nextOffset = sections[i + 1].offset;
+            sl = Math.min(stopLine, lineOffset + nextOffset.line), sl === stopLine ? sc = Math.min(stopColumn, columnOffset + nextOffset.column) : sl < stopLine && (sc = columnOffset + nextOffset.column);
+          }
+          addSection(
+            map,
+            mapUrl,
+            mappings,
+            sources,
+            sourcesContent,
+            names,
+            ignoreList,
+            lineOffset + offset.line,
+            columnOffset + offset.column,
+            sl,
+            sc
+          );
+        }
+      }
+      function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
+        let parsed = parse3(input);
+        if ("sections" in parsed) return recurse(...arguments);
+        let map = new TraceMap(parsed, mapUrl), sourcesOffset = sources.length, namesOffset = names.length, decoded = decodedMappings(map), { resolvedSources, sourcesContent: contents, ignoreList: ignores } = map;
+        if (append(sources, resolvedSources), append(names, map.names), contents) append(sourcesContent, contents);
+        else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
+        if (ignores) for (let i = 0; i < ignores.length; i++) ignoreList.push(ignores[i] + sourcesOffset);
+        for (let i = 0; i < decoded.length; i++) {
+          let lineI = lineOffset + i;
+          if (lineI > stopLine) return;
+          let out = getLine(mappings, lineI), cOffset = i === 0 ? columnOffset : 0, line = decoded[i];
+          for (let j = 0; j < line.length; j++) {
+            let seg = line[j], column = cOffset + seg[COLUMN];
+            if (lineI === stopLine && column >= stopColumn) return;
+            if (seg.length === 1) {
+              out.push([column]);
+              continue;
+            }
+            let sourcesIndex = sourcesOffset + seg[SOURCES_INDEX], sourceLine = seg[SOURCE_LINE], sourceColumn = seg[SOURCE_COLUMN];
+            out.push(
+              seg.length === 4 ? [column, sourcesIndex, sourceLine, sourceColumn] : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]
+            );
+          }
+        }
+      }
+      function append(arr, other) {
+        for (let i = 0; i < other.length; i++) arr.push(other[i]);
+      }
+      function getLine(arr, index) {
+        for (let i = arr.length; i <= index; i++) arr[i] = [];
+        return arr[index];
+      }
+      var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)", COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)", LEAST_UPPER_BOUND = -1, GREATEST_LOWER_BOUND = 1, TraceMap = class {
+        constructor(map, mapUrl) {
+          let isString = typeof map == "string";
+          if (!isString && map._decodedMemo) return map;
+          let parsed = parse3(map), { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+          this.version = version, this.file = file, this.names = names || [], this.sourceRoot = sourceRoot, this.sources = sources, this.sourcesContent = sourcesContent, this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+          let resolve = resolver(mapUrl, sourceRoot);
+          this.resolvedSources = sources.map(resolve);
+          let { mappings } = parsed;
+          if (typeof mappings == "string")
+            this._encoded = mappings, this._decoded = void 0;
+          else if (Array.isArray(mappings))
+            this._encoded = void 0, this._decoded = maybeSort(mappings, isString);
+          else throw parsed.sections ? new Error("TraceMap passed sectioned source map, please use FlattenMap export instead") : new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+          this._decodedMemo = memoizedState(), this._bySources = void 0, this._bySourceMemos = void 0;
+        }
+      };
+      function cast(map) {
+        return map;
+      }
+      function encodedMappings(map) {
+        var _a, _b;
+        return (_b = (_a = map)._encoded) != null ? _b : _a._encoded = (0, import_sourcemap_codec.encode)(map._decoded);
+      }
+      function decodedMappings(map) {
+        var _a;
+        return (_a = map)._decoded || (_a._decoded = (0, import_sourcemap_codec.decode)(map._encoded));
+      }
+      function traceSegment(map, line, column) {
+        let decoded = decodedMappings(map);
+        if (line >= decoded.length) return null;
+        let segments = decoded[line], index = traceSegmentInternal(
+          segments,
+          map._decodedMemo,
+          line,
+          column,
+          GREATEST_LOWER_BOUND
+        );
+        return index === -1 ? null : segments[index];
+      }
+      function originalPositionFor(map, needle) {
+        let { line, column, bias } = needle;
+        if (line--, line < 0) throw new Error(LINE_GTR_ZERO);
+        if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+        let decoded = decodedMappings(map);
+        if (line >= decoded.length) return OMapping(null, null, null, null);
+        let segments = decoded[line], index = traceSegmentInternal(
+          segments,
+          map._decodedMemo,
+          line,
+          column,
+          bias || GREATEST_LOWER_BOUND
+        );
+        if (index === -1) return OMapping(null, null, null, null);
+        let segment = segments[index];
+        if (segment.length === 1) return OMapping(null, null, null, null);
+        let { names, resolvedSources } = map;
+        return OMapping(
+          resolvedSources[segment[SOURCES_INDEX]],
+          segment[SOURCE_LINE] + 1,
+          segment[SOURCE_COLUMN],
+          segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+        );
+      }
+      function generatedPositionFor(map, needle) {
+        let { source, line, column, bias } = needle;
+        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, !1);
+      }
+      function allGeneratedPositionsFor(map, needle) {
+        let { source, line, column, bias } = needle;
+        return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, !0);
+      }
+      function eachMapping(map, cb) {
+        let decoded = decodedMappings(map), { names, resolvedSources } = map;
+        for (let i = 0; i < decoded.length; i++) {
+          let line = decoded[i];
+          for (let j = 0; j < line.length; j++) {
+            let seg = line[j], generatedLine = i + 1, generatedColumn = seg[0], source = null, originalLine = null, originalColumn = null, name = null;
+            seg.length !== 1 && (source = resolvedSources[seg[1]], originalLine = seg[2] + 1, originalColumn = seg[3]), seg.length === 5 && (name = names[seg[4]]), cb({
+              generatedLine,
+              generatedColumn,
+              source,
+              originalLine,
+              originalColumn,
+              name
+            });
+          }
+        }
+      }
+      function sourceIndex(map, source) {
+        let { sources, resolvedSources } = map, index = sources.indexOf(source);
+        return index === -1 && (index = resolvedSources.indexOf(source)), index;
+      }
+      function sourceContentFor(map, source) {
+        let { sourcesContent } = map;
+        if (sourcesContent == null) return null;
+        let index = sourceIndex(map, source);
+        return index === -1 ? null : sourcesContent[index];
+      }
+      function isIgnored(map, source) {
+        let { ignoreList } = map;
+        if (ignoreList == null) return !1;
+        let index = sourceIndex(map, source);
+        return index === -1 ? !1 : ignoreList.includes(index);
+      }
+      function presortedDecodedMap(map, mapUrl) {
+        let tracer = new TraceMap(clone(map, []), mapUrl);
+        return tracer._decoded = map.mappings, tracer;
+      }
+      function decodedMap(map) {
+        return clone(map, decodedMappings(map));
+      }
+      function encodedMap(map) {
+        return clone(map, encodedMappings(map));
+      }
+      function clone(map, mappings) {
+        return {
+          version: map.version,
+          file: map.file,
+          names: map.names,
+          sourceRoot: map.sourceRoot,
+          sources: map.sources,
+          sourcesContent: map.sourcesContent,
+          mappings,
+          ignoreList: map.ignoreList || map.x_google_ignoreList
+        };
+      }
+      function OMapping(source, line, column, name) {
+        return { source, line, column, name };
+      }
+      function GMapping(line, column) {
+        return { line, column };
+      }
+      function traceSegmentInternal(segments, memo, line, column, bias) {
+        let index = memoizedBinarySearch(segments, column, memo, line);
+        return found ? index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index) : bias === LEAST_UPPER_BOUND && index++, index === -1 || index === segments.length ? -1 : index;
+      }
+      function sliceGeneratedPositions(segments, memo, line, column, bias) {
+        let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
+        if (!found && bias === LEAST_UPPER_BOUND && min++, min === -1 || min === segments.length) return [];
+        let matchedColumn = found ? column : segments[min][COLUMN];
+        found || (min = lowerBound(segments, matchedColumn, min));
+        let max = upperBound(segments, matchedColumn, min), result = [];
+        for (; min <= max; min++) {
+          let segment = segments[min];
+          result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+        }
+        return result;
+      }
+      function generatedPosition(map, source, line, column, bias, all) {
+        var _a, _b;
+        if (line--, line < 0) throw new Error(LINE_GTR_ZERO);
+        if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+        let { sources, resolvedSources } = map, sourceIndex2 = sources.indexOf(source);
+        if (sourceIndex2 === -1 && (sourceIndex2 = resolvedSources.indexOf(source)), sourceIndex2 === -1) return all ? [] : GMapping(null, null);
+        let bySourceMemos = (_a = map)._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState)), segments = ((_b = map)._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos)))[sourceIndex2][line];
+        if (segments == null) return all ? [] : GMapping(null, null);
+        let memo = bySourceMemos[sourceIndex2];
+        if (all) return sliceGeneratedPositions(segments, memo, line, column, bias);
+        let index = traceSegmentInternal(segments, memo, line, column, bias);
+        if (index === -1) return GMapping(null, null);
+        let segment = segments[index];
+        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+      }
+    }));
+  }
+});
+
+// ../node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
+var require_gen_mapping_umd = __commonJS({
+  "../node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js"(exports, module) {
+    (function(global2, factory) {
+      if (typeof exports == "object" && typeof module < "u")
+        factory(module, require_sourcemap_codec_umd(), require_trace_mapping_umd()), module.exports = def(module);
+      else if (typeof define == "function" && define.amd)
+        define(["module", "@jridgewell/sourcemap-codec", "@jridgewell/trace-mapping"], function(mod) {
+          factory.apply(this, arguments), mod.exports = def(mod);
+        });
+      else {
+        let mod = { exports: {} };
+        factory(mod, global2.sourcemapCodec, global2.traceMapping), global2 = typeof globalThis < "u" ? globalThis : global2 || self, global2.genMapping = def(mod);
+      }
+      function def(m) {
+        return "default" in m.exports ? m.exports.default : m.exports;
+      }
+    })(exports, (function(module2, require_sourcemapCodec, require_traceMapping) {
+      "use strict";
+      var __create = Object.create, __defProp = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropNames = Object.getOwnPropertyNames, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __commonJS2 = (cb, mod) => function() {
+        return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+      }, __export = (target, all) => {
+        for (var name in all)
+          __defProp(target, name, { get: all[name], enumerable: !0 });
+      }, __copyProps = (to, from, except, desc) => {
+        if (from && typeof from == "object" || typeof from == "function")
+          for (let key of __getOwnPropNames(from))
+            !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+        return to;
+      }, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+        // If the importer is in node compatibility mode or this is not an ESM
+        // file that has been converted to a CommonJS file using a Babel-
+        // compatible transform (i.e. "__esModule" has not been set), then set
+        // "default" to the CommonJS "module.exports" for node compatibility.
+        isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+        mod
+      )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod), require_sourcemap_codec = __commonJS2({
+        "umd:@jridgewell/sourcemap-codec"(exports2, module22) {
+          module22.exports = require_sourcemapCodec;
+        }
+      }), require_trace_mapping = __commonJS2({
+        "umd:@jridgewell/trace-mapping"(exports2, module22) {
+          module22.exports = require_traceMapping;
+        }
+      }), gen_mapping_exports = {};
+      __export(gen_mapping_exports, {
+        GenMapping: () => GenMapping,
+        addMapping: () => addMapping,
+        addSegment: () => addSegment,
+        allMappings: () => allMappings,
+        fromMap: () => fromMap,
+        maybeAddMapping: () => maybeAddMapping,
+        maybeAddSegment: () => maybeAddSegment,
+        setIgnore: () => setIgnore,
+        setSourceContent: () => setSourceContent,
+        toDecodedMap: () => toDecodedMap,
+        toEncodedMap: () => toEncodedMap
+      }), module2.exports = __toCommonJS(gen_mapping_exports);
+      var SetArray = class {
+        constructor() {
+          this._indexes = { __proto__: null }, this.array = [];
+        }
+      };
+      function cast(set) {
+        return set;
+      }
+      function get(setarr, key) {
+        return setarr._indexes[key];
+      }
+      function put(setarr, key) {
+        let index = get(setarr, key);
+        if (index !== void 0) return index;
+        let { array, _indexes: indexes } = setarr, length = array.push(key);
+        return indexes[key] = length - 1;
+      }
+      function remove(setarr, key) {
+        let index = get(setarr, key);
+        if (index === void 0) return;
+        let { array, _indexes: indexes } = setarr;
+        for (let i = index + 1; i < array.length; i++) {
+          let k = array[i];
+          array[i - 1] = k, indexes[k]--;
+        }
+        indexes[key] = void 0, array.pop();
+      }
+      var import_sourcemap_codec = __toESM2(require_sourcemap_codec()), import_trace_mapping = __toESM2(require_trace_mapping()), COLUMN = 0, SOURCES_INDEX = 1, SOURCE_LINE = 2, SOURCE_COLUMN = 3, NAMES_INDEX = 4, NO_NAME = -1, GenMapping = class {
+        constructor({ file, sourceRoot } = {}) {
+          this._names = new SetArray(), this._sources = new SetArray(), this._sourcesContent = [], this._mappings = [], this.file = file, this.sourceRoot = sourceRoot, this._ignoreList = new SetArray();
+        }
+      };
+      function cast2(map) {
+        return map;
+      }
+      function addSegment(map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+        return addSegmentInternal(
+          !1,
+          map,
+          genLine,
+          genColumn,
+          source,
+          sourceLine,
+          sourceColumn,
+          name,
+          content
+        );
+      }
+      function addMapping(map, mapping) {
+        return addMappingInternal(!1, map, mapping);
+      }
+      var maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => addSegmentInternal(
+        !0,
+        map,
+        genLine,
+        genColumn,
+        source,
+        sourceLine,
+        sourceColumn,
+        name,
+        content
+      ), maybeAddMapping = (map, mapping) => addMappingInternal(!0, map, mapping);
+      function setSourceContent(map, source, content) {
+        let {
+          _sources: sources,
+          _sourcesContent: sourcesContent
+          // _originalScopes: originalScopes,
+        } = map, index = put(sources, source);
+        sourcesContent[index] = content;
+      }
+      function setIgnore(map, source, ignore = !0) {
+        let {
+          _sources: sources,
+          _sourcesContent: sourcesContent,
+          _ignoreList: ignoreList
+          // _originalScopes: originalScopes,
+        } = map, index = put(sources, source);
+        index === sourcesContent.length && (sourcesContent[index] = null), ignore ? put(ignoreList, index) : remove(ignoreList, index);
+      }
+      function toDecodedMap(map) {
+        let {
+          _mappings: mappings,
+          _sources: sources,
+          _sourcesContent: sourcesContent,
+          _names: names,
+          _ignoreList: ignoreList
+          // _originalScopes: originalScopes,
+          // _generatedRanges: generatedRanges,
+        } = map;
+        return removeEmptyFinalLines(mappings), {
+          version: 3,
+          file: map.file || void 0,
+          names: names.array,
+          sourceRoot: map.sourceRoot || void 0,
+          sources: sources.array,
+          sourcesContent,
+          mappings,
+          // originalScopes,
+          // generatedRanges,
+          ignoreList: ignoreList.array
+        };
+      }
+      function toEncodedMap(map) {
+        let decoded = toDecodedMap(map);
+        return Object.assign({}, decoded, {
+          // originalScopes: decoded.originalScopes.map((os) => encodeOriginalScopes(os)),
+          // generatedRanges: encodeGeneratedRanges(decoded.generatedRanges as GeneratedRange[]),
+          mappings: (0, import_sourcemap_codec.encode)(decoded.mappings)
+        });
+      }
+      function fromMap(input) {
+        let map = new import_trace_mapping.TraceMap(input), gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
+        return putAll(gen._names, map.names), putAll(gen._sources, map.sources), gen._sourcesContent = map.sourcesContent || map.sources.map(() => null), gen._mappings = (0, import_trace_mapping.decodedMappings)(map), map.ignoreList && putAll(gen._ignoreList, map.ignoreList), gen;
+      }
+      function allMappings(map) {
+        let out = [], { _mappings: mappings, _sources: sources, _names: names } = map;
+        for (let i = 0; i < mappings.length; i++) {
+          let line = mappings[i];
+          for (let j = 0; j < line.length; j++) {
+            let seg = line[j], generated = { line: i + 1, column: seg[COLUMN] }, source, original, name;
+            seg.length !== 1 && (source = sources.array[seg[SOURCES_INDEX]], original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] }, seg.length === 5 && (name = names.array[seg[NAMES_INDEX]])), out.push({ generated, source, original, name });
+          }
+        }
+        return out;
+      }
+      function addSegmentInternal(skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) {
+        let {
+          _mappings: mappings,
+          _sources: sources,
+          _sourcesContent: sourcesContent,
+          _names: names
+          // _originalScopes: originalScopes,
+        } = map, line = getIndex(mappings, genLine), index = getColumnIndex(line, genColumn);
+        if (!source)
+          return skipable && skipSourceless(line, index) ? void 0 : insert(line, index, [genColumn]);
+        let sourcesIndex = put(sources, source), namesIndex = name ? put(names, name) : NO_NAME;
+        if (sourcesIndex === sourcesContent.length && (sourcesContent[sourcesIndex] = content ?? null), !(skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)))
+          return insert(
+            line,
+            index,
+            name ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex] : [genColumn, sourcesIndex, sourceLine, sourceColumn]
+          );
+      }
+      function assert(_val) {
+      }
+      function getIndex(arr, index) {
+        for (let i = arr.length; i <= index; i++)
+          arr[i] = [];
+        return arr[index];
+      }
+      function getColumnIndex(line, genColumn) {
+        let index = line.length;
+        for (let i = index - 1; i >= 0; index = i--) {
+          let current = line[i];
+          if (genColumn >= current[COLUMN]) break;
+        }
+        return index;
+      }
+      function insert(array, index, value2) {
+        for (let i = array.length; i > index; i--)
+          array[i] = array[i - 1];
+        array[index] = value2;
+      }
+      function removeEmptyFinalLines(mappings) {
+        let { length } = mappings, len = length;
+        for (let i = len - 1; i >= 0 && !(mappings[i].length > 0); len = i, i--)
+          ;
+        len < length && (mappings.length = len);
+      }
+      function putAll(setarr, array) {
+        for (let i = 0; i < array.length; i++) put(setarr, array[i]);
+      }
+      function skipSourceless(line, index) {
+        return index === 0 ? !0 : line[index - 1].length === 1;
+      }
+      function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
+        if (index === 0) return !1;
+        let prev = line[index - 1];
+        return prev.length === 1 ? !1 : sourcesIndex === prev[SOURCES_INDEX] && sourceLine === prev[SOURCE_LINE] && sourceColumn === prev[SOURCE_COLUMN] && namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME);
+      }
+      function addMappingInternal(skipable, map, mapping) {
+        let { generated, source, original, name, content } = mapping;
+        return source ? addSegmentInternal(
+          skipable,
+          map,
+          generated.line - 1,
+          generated.column,
+          source,
+          original.line - 1,
+          original.column,
+          name,
+          content
+        ) : addSegmentInternal(
+          skipable,
+          map,
+          generated.line - 1,
+          generated.column,
+          null,
+          null,
+          null,
+          null,
+          null
+        );
+      }
+    }));
+  }
+});
+
 // ../node_modules/@babel/generator/lib/source-map.js
 var require_source_map = __commonJS({
   "../node_modules/@babel/generator/lib/source-map.js"(exports) {