import CJS_COMPAT_NODE_URL_fkaa0x0zihe from 'node:url';
import CJS_COMPAT_NODE_PATH_fkaa0x0zihe from 'node:path';
import CJS_COMPAT_NODE_MODULE_fkaa0x0zihe from "node:module";

var __filename = CJS_COMPAT_NODE_URL_fkaa0x0zihe.fileURLToPath(import.meta.url);
var __dirname = CJS_COMPAT_NODE_PATH_fkaa0x0zihe.dirname(__filename);
var require = CJS_COMPAT_NODE_MODULE_fkaa0x0zihe.createRequire(import.meta.url);

// ------------------------------------------------------------
// end of CJS compatibility banner, injected by Storybook's esbuild configuration
// ------------------------------------------------------------
import {
  __commonJS
} from "./chunk-4ILNNMLG.js";

// ../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(global, factory) {
      typeof exports == "object" && typeof module < "u" ? module.exports = factory() : typeof define == "function" && define.amd ? define(factory) : (global = typeof globalThis < "u" ? globalThis : global || self, global.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/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(global, 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), global = typeof globalThis < "u" ? globalThis : global || self, global.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 value = 0, shift = 0, integer = 0;
        do {
          let c = reader.next();
          integer = charToInt[c], value |= (integer & 31) << shift, shift += 5;
        } while (integer & 32);
        let shouldNegate = value & 1;
        return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative + value;
      }
      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/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(global, 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, global.resolveURI, global.sourcemapCodec), global = typeof globalThis < "u" ? globalThis : global || self, global.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;
      }, __toESM = (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 = __toESM(require_sourcemap_codec()), import_resolve_uri = __toESM(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 parse(map) {
        return typeof map == "string" ? JSON.parse(map) : map;
      }
      var FlattenMap = function(map, mapUrl) {
        let parsed = parse(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 = parse(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 = parse(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(global, 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, global.sourcemapCodec, global.traceMapping), global = typeof globalThis < "u" ? globalThis : global || self, global.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;
      }, __toESM = (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 = __toESM(require_sourcemap_codec()), import_trace_mapping = __toESM(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, value) {
        for (let i = array.length; i > index; i--)
          array[i] = array[i - 1];
        array[index] = value;
      }
      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
        );
      }
    }));
  }
});

export {
  require_trace_mapping_umd,
  require_gen_mapping_umd
};
