@rsbuild/core 1.5.12 → 1.5.13

package/compiled/@jridgewell/trace-mapping/index.js

@@ -0,0 +1,1408 @@
+(() => {
+  var __webpack_modules__ = {
+    738: function (module) {
+      (function (global, factory) {
+        true ? (module.exports = factory()) : 0;
+      })(this, function () {
+        "use strict";
+        const schemeRegex = /^[\w+.-]+:\/\//;
+        const urlRegex =
+          /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+        const 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) {
+          const match = urlRegex.exec(input);
+          return makeUrl(
+            match[1],
+            match[2] || "",
+            match[3],
+            match[4] || "",
+            match[5] || "/",
+            match[6] || "",
+            match[7] || "",
+          );
+        }
+        function parseFileUrl(input) {
+          const match = fileRegex.exec(input);
+          const 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)) {
+            const url = parseAbsoluteUrl("http:" + input);
+            url.scheme = "";
+            url.type = 6;
+            return url;
+          }
+          if (isAbsolutePath(input)) {
+            const url = parseAbsoluteUrl("http://foo.com" + input);
+            url.scheme = "";
+            url.host = "";
+            url.type = 5;
+            return url;
+          }
+          if (isFileUrl(input)) return parseFileUrl(input);
+          if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+          const url = parseAbsoluteUrl("http://foo.com/" + input);
+          url.scheme = "";
+          url.host = "";
+          url.type = input
+            ? input.startsWith("?")
+              ? 3
+              : input.startsWith("#")
+                ? 2
+                : 4
+            : 1;
+          return url;
+        }
+        function stripPathFilename(path) {
+          if (path.endsWith("/..")) return path;
+          const index = path.lastIndexOf("/");
+          return path.slice(0, index + 1);
+        }
+        function mergePaths(url, base) {
+          normalizePath(base, base.type);
+          if (url.path === "/") {
+            url.path = base.path;
+          } else {
+            url.path = stripPathFilename(base.path) + url.path;
+          }
+        }
+        function normalizePath(url, type) {
+          const rel = type <= 4;
+          const pieces = url.path.split("/");
+          let pointer = 1;
+          let positive = 0;
+          let addTrailingSlash = false;
+          for (let i = 1; i < pieces.length; i++) {
+            const piece = pieces[i];
+            if (!piece) {
+              addTrailingSlash = true;
+              continue;
+            }
+            addTrailingSlash = false;
+            if (piece === ".") continue;
+            if (piece === "..") {
+              if (positive) {
+                addTrailingSlash = true;
+                positive--;
+                pointer--;
+              } else if (rel) {
+                pieces[pointer++] = piece;
+              }
+              continue;
+            }
+            pieces[pointer++] = piece;
+            positive++;
+          }
+          let path = "";
+          for (let i = 1; i < pointer; i++) {
+            path += "/" + pieces[i];
+          }
+          if (!path || (addTrailingSlash && !path.endsWith("/.."))) {
+            path += "/";
+          }
+          url.path = path;
+        }
+        function resolve(input, base) {
+          if (!input && !base) return "";
+          const url = parseUrl(input);
+          let inputType = url.type;
+          if (base && inputType !== 7) {
+            const baseUrl = parseUrl(base);
+            const baseType = baseUrl.type;
+            switch (inputType) {
+              case 1:
+                url.hash = baseUrl.hash;
+              case 2:
+                url.query = baseUrl.query;
+              case 3:
+              case 4:
+                mergePaths(url, baseUrl);
+              case 5:
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+              case 6:
+                url.scheme = baseUrl.scheme;
+            }
+            if (baseType > inputType) inputType = baseType;
+          }
+          normalizePath(url, inputType);
+          const queryHash = url.query + url.hash;
+          switch (inputType) {
+            case 2:
+            case 3:
+              return queryHash;
+            case 4: {
+              const path = url.path.slice(1);
+              if (!path) return queryHash || ".";
+              if (isRelative(base || input) && !isRelative(path)) {
+                return "./" + path + queryHash;
+              }
+              return path + queryHash;
+            }
+            case 5:
+              return url.path + queryHash;
+            default:
+              return (
+                url.scheme +
+                "//" +
+                url.user +
+                url.host +
+                url.port +
+                url.path +
+                queryHash
+              );
+          }
+        }
+        return resolve;
+      });
+    },
+    26: function (module, __unused_webpack_exports, __nccwpck_require__) {
+      module = __nccwpck_require__.nmd(module);
+      (function (global, factory) {
+        if (true) {
+          factory(module);
+          module.exports = def(module);
+        } else {
+        }
+        function def(m) {
+          return "default" in m.exports ? m.exports.default : m.exports;
+        }
+      })(this, function (module) {
+        "use strict";
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __export = (target, all) => {
+          for (var name in all)
+            __defProp(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps = (to, from, except, desc) => {
+          if (
+            (from && typeof from === "object") ||
+            typeof from === "function"
+          ) {
+            for (let key of __getOwnPropNames(from))
+              if (!__hasOwnProp.call(to, key) && key !== except)
+                __defProp(to, key, {
+                  get: () => from[key],
+                  enumerable:
+                    !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+                });
+          }
+          return to;
+        };
+        var __toCommonJS = (mod) =>
+          __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+        var sourcemap_codec_exports = {};
+        __export(sourcemap_codec_exports, {
+          decode: () => decode,
+          decodeGeneratedRanges: () => decodeGeneratedRanges,
+          decodeOriginalScopes: () => decodeOriginalScopes,
+          encode: () => encode,
+          encodeGeneratedRanges: () => encodeGeneratedRanges,
+          encodeOriginalScopes: () => encodeOriginalScopes,
+        });
+        module.exports = __toCommonJS(sourcemap_codec_exports);
+        var comma = ",".charCodeAt(0);
+        var semicolon = ";".charCodeAt(0);
+        var chars =
+          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        var intToChar = new Uint8Array(64);
+        var charToInt = new Uint8Array(128);
+        for (let i = 0; i < chars.length; i++) {
+          const c = chars.charCodeAt(i);
+          intToChar[i] = c;
+          charToInt[c] = i;
+        }
+        function decodeInteger(reader, relative) {
+          let value = 0;
+          let shift = 0;
+          let integer = 0;
+          do {
+            const c = reader.next();
+            integer = charToInt[c];
+            value |= (integer & 31) << shift;
+            shift += 5;
+          } while (integer & 32);
+          const shouldNegate = value & 1;
+          value >>>= 1;
+          if (shouldNegate) {
+            value = -2147483648 | -value;
+          }
+          return 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;
+            if (delta > 0) clamped |= 32;
+            builder.write(intToChar[clamped]);
+          } while (delta > 0);
+          return num;
+        }
+        function hasMoreVlq(reader, max) {
+          if (reader.pos >= max) return false;
+          return reader.peek() !== comma;
+        }
+        var bufLength = 1024 * 16;
+        var td =
+          typeof TextDecoder !== "undefined"
+            ? new TextDecoder()
+            : typeof Buffer !== "undefined"
+              ? {
+                  decode(buf) {
+                    const out = Buffer.from(
+                      buf.buffer,
+                      buf.byteOffset,
+                      buf.byteLength,
+                    );
+                    return out.toString();
+                  },
+                }
+              : {
+                  decode(buf) {
+                    let out = "";
+                    for (let i = 0; i < buf.length; i++) {
+                      out += String.fromCharCode(buf[i]);
+                    }
+                    return out;
+                  },
+                };
+        var StringWriter = class {
+          constructor() {
+            this.pos = 0;
+            this.out = "";
+            this.buffer = new Uint8Array(bufLength);
+          }
+          write(v) {
+            const { buffer } = this;
+            buffer[this.pos++] = v;
+            if (this.pos === bufLength) {
+              this.out += td.decode(buffer);
+              this.pos = 0;
+            }
+          }
+          flush() {
+            const { buffer, out, pos } = this;
+            return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+          }
+        };
+        var 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) {
+            const { buffer, pos } = this;
+            const idx = buffer.indexOf(char, pos);
+            return idx === -1 ? buffer.length : idx;
+          }
+        };
+        var EMPTY = [];
+        function decodeOriginalScopes(input) {
+          const { length } = input;
+          const reader = new StringReader(input);
+          const scopes = [];
+          const stack = [];
+          let line = 0;
+          for (; reader.pos < length; reader.pos++) {
+            line = decodeInteger(reader, line);
+            const column = decodeInteger(reader, 0);
+            if (!hasMoreVlq(reader, length)) {
+              const last = stack.pop();
+              last[2] = line;
+              last[3] = column;
+              continue;
+            }
+            const kind = decodeInteger(reader, 0);
+            const fields = decodeInteger(reader, 0);
+            const hasName = fields & 1;
+            const scope = hasName
+              ? [line, column, 0, 0, kind, decodeInteger(reader, 0)]
+              : [line, column, 0, 0, kind];
+            let vars = EMPTY;
+            if (hasMoreVlq(reader, length)) {
+              vars = [];
+              do {
+                const 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) {
+          const 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) {
+          const scope = scopes[index];
+          const {
+            0: startLine,
+            1: startColumn,
+            2: endLine,
+            3: endColumn,
+            4: kind,
+            vars,
+          } = scope;
+          if (index > 0) writer.write(comma);
+          state[0] = encodeInteger(writer, startLine, state[0]);
+          encodeInteger(writer, startColumn, 0);
+          encodeInteger(writer, kind, 0);
+          const fields = scope.length === 6 ? 1 : 0;
+          encodeInteger(writer, fields, 0);
+          if (scope.length === 6) encodeInteger(writer, scope[5], 0);
+          for (const v of vars) {
+            encodeInteger(writer, v, 0);
+          }
+          for (index++; index < scopes.length; ) {
+            const next = scopes[index];
+            const { 0: l, 1: c } = next;
+            if (l > endLine || (l === endLine && c >= endColumn)) {
+              break;
+            }
+            index = _encodeOriginalScopes(scopes, index, writer, state);
+          }
+          writer.write(comma);
+          state[0] = encodeInteger(writer, endLine, state[0]);
+          encodeInteger(writer, endColumn, 0);
+          return index;
+        }
+        function decodeGeneratedRanges(input) {
+          const { length } = input;
+          const reader = new StringReader(input);
+          const ranges = [];
+          const stack = [];
+          let genLine = 0;
+          let definitionSourcesIndex = 0;
+          let definitionScopeIndex = 0;
+          let callsiteSourcesIndex = 0;
+          let callsiteLine = 0;
+          let callsiteColumn = 0;
+          let bindingLine = 0;
+          let bindingColumn = 0;
+          do {
+            const semi = reader.indexOf(";");
+            let genColumn = 0;
+            for (; reader.pos < semi; reader.pos++) {
+              genColumn = decodeInteger(reader, genColumn);
+              if (!hasMoreVlq(reader, semi)) {
+                const last = stack.pop();
+                last[2] = genLine;
+                last[3] = genColumn;
+                continue;
+              }
+              const fields = decodeInteger(reader, 0);
+              const hasDefinition = fields & 1;
+              const hasCallsite = fields & 2;
+              const hasScope = fields & 4;
+              let callsite = null;
+              let bindings = EMPTY;
+              let range;
+              if (hasDefinition) {
+                const 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];
+              }
+              range.isScope = !!hasScope;
+              if (hasCallsite) {
+                const prevCsi = callsiteSourcesIndex;
+                const prevLine = callsiteLine;
+                callsiteSourcesIndex = decodeInteger(
+                  reader,
+                  callsiteSourcesIndex,
+                );
+                const sameSource = prevCsi === callsiteSourcesIndex;
+                callsiteLine = decodeInteger(
+                  reader,
+                  sameSource ? callsiteLine : 0,
+                );
+                callsiteColumn = decodeInteger(
+                  reader,
+                  sameSource && prevLine === callsiteLine ? callsiteColumn : 0,
+                );
+                callsite = [callsiteSourcesIndex, callsiteLine, callsiteColumn];
+              }
+              range.callsite = callsite;
+              if (hasMoreVlq(reader, semi)) {
+                bindings = [];
+                do {
+                  bindingLine = genLine;
+                  bindingColumn = genColumn;
+                  const expressionsCount = decodeInteger(reader, 0);
+                  let expressionRanges;
+                  if (expressionsCount < -1) {
+                    expressionRanges = [[decodeInteger(reader, 0)]];
+                    for (let i = -1; i > expressionsCount; i--) {
+                      const prevBl = bindingLine;
+                      bindingLine = decodeInteger(reader, bindingLine);
+                      bindingColumn = decodeInteger(
+                        reader,
+                        bindingLine === prevBl ? bindingColumn : 0,
+                      );
+                      const 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 "";
+          const 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) {
+          const range = ranges[index];
+          const {
+            0: startLine,
+            1: startColumn,
+            2: endLine,
+            3: endColumn,
+            isScope,
+            callsite,
+            bindings,
+          } = range;
+          if (state[0] < startLine) {
+            catchupLine(writer, state[0], startLine);
+            state[0] = startLine;
+            state[1] = 0;
+          } else if (index > 0) {
+            writer.write(comma);
+          }
+          state[1] = encodeInteger(writer, range[1], state[1]);
+          const fields =
+            (range.length === 6 ? 1 : 0) |
+            (callsite ? 2 : 0) |
+            (isScope ? 4 : 0);
+          encodeInteger(writer, fields, 0);
+          if (range.length === 6) {
+            const { 4: sourcesIndex, 5: scopesIndex } = range;
+            if (sourcesIndex !== state[2]) {
+              state[3] = 0;
+            }
+            state[2] = encodeInteger(writer, sourcesIndex, state[2]);
+            state[3] = encodeInteger(writer, scopesIndex, state[3]);
+          }
+          if (callsite) {
+            const {
+              0: sourcesIndex,
+              1: callLine,
+              2: callColumn,
+            } = range.callsite;
+            if (sourcesIndex !== state[4]) {
+              state[5] = 0;
+              state[6] = 0;
+            } else if (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 (const binding of bindings) {
+              if (binding.length > 1) encodeInteger(writer, -binding.length, 0);
+              const expression = binding[0][0];
+              encodeInteger(writer, expression, 0);
+              let bindingStartLine = startLine;
+              let bindingStartColumn = startColumn;
+              for (let i = 1; i < binding.length; i++) {
+                const 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; ) {
+            const next = ranges[index];
+            const { 0: l, 1: c } = next;
+            if (l > endLine || (l === endLine && c >= endColumn)) {
+              break;
+            }
+            index = _encodeGeneratedRanges(ranges, index, writer, state);
+          }
+          if (state[0] < endLine) {
+            catchupLine(writer, state[0], endLine);
+            state[0] = endLine;
+            state[1] = 0;
+          } else {
+            writer.write(comma);
+          }
+          state[1] = encodeInteger(writer, endColumn, state[1]);
+          return index;
+        }
+        function catchupLine(writer, lastLine, line) {
+          do {
+            writer.write(semicolon);
+          } while (++lastLine < line);
+        }
+        function decode(mappings) {
+          const { length } = mappings;
+          const reader = new StringReader(mappings);
+          const decoded = [];
+          let genColumn = 0;
+          let sourcesIndex = 0;
+          let sourceLine = 0;
+          let sourceColumn = 0;
+          let namesIndex = 0;
+          do {
+            const semi = reader.indexOf(";");
+            const line = [];
+            let sorted = true;
+            let lastCol = 0;
+            genColumn = 0;
+            while (reader.pos < semi) {
+              let seg;
+              genColumn = decodeInteger(reader, genColumn);
+              if (genColumn < lastCol) sorted = false;
+              lastCol = genColumn;
+              if (hasMoreVlq(reader, semi)) {
+                sourcesIndex = decodeInteger(reader, sourcesIndex);
+                sourceLine = decodeInteger(reader, sourceLine);
+                sourceColumn = decodeInteger(reader, sourceColumn);
+                if (hasMoreVlq(reader, semi)) {
+                  namesIndex = decodeInteger(reader, namesIndex);
+                  seg = [
+                    genColumn,
+                    sourcesIndex,
+                    sourceLine,
+                    sourceColumn,
+                    namesIndex,
+                  ];
+                } else {
+                  seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+                }
+              } else {
+                seg = [genColumn];
+              }
+              line.push(seg);
+              reader.pos++;
+            }
+            if (!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) {
+          const writer = new StringWriter();
+          let sourcesIndex = 0;
+          let sourceLine = 0;
+          let sourceColumn = 0;
+          let namesIndex = 0;
+          for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            if (i > 0) writer.write(semicolon);
+            if (line.length === 0) continue;
+            let genColumn = 0;
+            for (let j = 0; j < line.length; j++) {
+              const segment = line[j];
+              if (j > 0) writer.write(comma);
+              genColumn = encodeInteger(writer, segment[0], genColumn);
+              if (segment.length === 1) continue;
+              sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+              sourceLine = encodeInteger(writer, segment[2], sourceLine);
+              sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
+              if (segment.length === 4) continue;
+              namesIndex = encodeInteger(writer, segment[4], namesIndex);
+            }
+          }
+          return writer.flush();
+        }
+      });
+    },
+    118: function (module, __unused_webpack_exports, __nccwpck_require__) {
+      module = __nccwpck_require__.nmd(module);
+      (function (global, factory) {
+        if (true) {
+          factory(module, __nccwpck_require__(738), __nccwpck_require__(26));
+          module.exports = def(module);
+        } else {
+        }
+        function def(m) {
+          return "default" in m.exports ? m.exports.default : m.exports;
+        }
+      })(this, function (module, require_resolveURI, require_sourcemapCodec) {
+        "use strict";
+        var __create = Object.create;
+        var __defProp = Object.defineProperty;
+        var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames = Object.getOwnPropertyNames;
+        var __getProtoOf = Object.getPrototypeOf;
+        var __hasOwnProp = Object.prototype.hasOwnProperty;
+        var __commonJS = (cb, mod) =>
+          function __require() {
+            return (
+              mod ||
+                (0, cb[__getOwnPropNames(cb)[0]])(
+                  (mod = { exports: {} }).exports,
+                  mod,
+                ),
+              mod.exports
+            );
+          };
+        var __export = (target, all) => {
+          for (var name in all)
+            __defProp(target, name, { get: all[name], enumerable: true });
+        };
+        var __copyProps = (to, from, except, desc) => {
+          if (
+            (from && typeof from === "object") ||
+            typeof from === "function"
+          ) {
+            for (let key of __getOwnPropNames(from))
+              if (!__hasOwnProp.call(to, key) && key !== except)
+                __defProp(to, key, {
+                  get: () => from[key],
+                  enumerable:
+                    !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+                });
+          }
+          return to;
+        };
+        var __toESM = (mod, isNodeMode, target) => (
+          (target = mod != null ? __create(__getProtoOf(mod)) : {}),
+          __copyProps(
+            isNodeMode || !mod || !mod.__esModule
+              ? __defProp(target, "default", { value: mod, enumerable: true })
+              : target,
+            mod,
+          )
+        );
+        var __toCommonJS = (mod) =>
+          __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+        var require_sourcemap_codec = __commonJS({
+          "umd:@jridgewell/sourcemap-codec"(exports, module2) {
+            module2.exports = require_sourcemapCodec;
+          },
+        });
+        var require_resolve_uri = __commonJS({
+          "umd:@jridgewell/resolve-uri"(exports, module2) {
+            module2.exports = require_resolveURI;
+          },
+        });
+        var 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,
+        });
+        module.exports = __toCommonJS(trace_mapping_exports);
+        var import_sourcemap_codec = __toESM(require_sourcemap_codec());
+        var import_resolve_uri = __toESM(require_resolve_uri());
+        function stripFilename(path) {
+          if (!path) return "";
+          const index = path.lastIndexOf("/");
+          return path.slice(0, index + 1);
+        }
+        function resolver(mapUrl, sourceRoot) {
+          const from = stripFilename(mapUrl);
+          const prefix = sourceRoot ? sourceRoot + "/" : "";
+          return (source) =>
+            (0, import_resolve_uri.default)(prefix + (source || ""), from);
+        }
+        var COLUMN = 0;
+        var SOURCES_INDEX = 1;
+        var SOURCE_LINE = 2;
+        var SOURCE_COLUMN = 3;
+        var NAMES_INDEX = 4;
+        var REV_GENERATED_LINE = 1;
+        var REV_GENERATED_COLUMN = 2;
+        function maybeSort(mappings, owned) {
+          const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+          if (unsortedIndex === mappings.length) return mappings;
+          if (!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 false;
+            }
+          }
+          return true;
+        }
+        function sortSegments(line, owned) {
+          if (!owned) line = line.slice();
+          return line.sort(sortComparator);
+        }
+        function sortComparator(a, b) {
+          return a[COLUMN] - b[COLUMN];
+        }
+        function buildBySources(decoded, memos) {
+          const sources = memos.map(() => []);
+          for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+              const seg = line[j];
+              if (seg.length === 1) continue;
+              const sourceIndex2 = seg[SOURCES_INDEX];
+              const sourceLine = seg[SOURCE_LINE];
+              const sourceColumn = seg[SOURCE_COLUMN];
+              const source = sources[sourceIndex2];
+              const segs = source[sourceLine] || (source[sourceLine] = []);
+              segs.push([sourceColumn, i, seg[COLUMN]]);
+            }
+          }
+          for (let i = 0; i < sources.length; i++) {
+            const source = sources[i];
+            for (let j = 0; j < source.length; j++) {
+              const line = source[j];
+              if (line) line.sort(sortComparator);
+            }
+          }
+          return sources;
+        }
+        var found = false;
+        function binarySearch(haystack, needle, low, high) {
+          while (low <= high) {
+            const mid = low + ((high - low) >> 1);
+            const cmp = haystack[mid][COLUMN] - needle;
+            if (cmp === 0) {
+              found = true;
+              return mid;
+            }
+            if (cmp < 0) {
+              low = mid + 1;
+            } else {
+              high = mid - 1;
+            }
+          }
+          found = false;
+          return low - 1;
+        }
+        function upperBound(haystack, needle, index) {
+          for (let i = index + 1; i < haystack.length; index = i++) {
+            if (haystack[i][COLUMN] !== needle) break;
+          }
+          return index;
+        }
+        function lowerBound(haystack, needle, index) {
+          for (let i = index - 1; i >= 0; index = i--) {
+            if (haystack[i][COLUMN] !== needle) break;
+          }
+          return index;
+        }
+        function memoizedState() {
+          return { lastKey: -1, lastNeedle: -1, lastIndex: -1 };
+        }
+        function memoizedBinarySearch(haystack, needle, state, key) {
+          const { lastKey, lastNeedle, lastIndex } = state;
+          let low = 0;
+          let high = haystack.length - 1;
+          if (key === lastKey) {
+            if (needle === lastNeedle) {
+              found =
+                lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+              return lastIndex;
+            }
+            if (needle >= lastNeedle) {
+              low = lastIndex === -1 ? 0 : lastIndex;
+            } else {
+              high = lastIndex;
+            }
+          }
+          state.lastKey = key;
+          state.lastNeedle = needle;
+          return (state.lastIndex = binarySearch(haystack, needle, low, high));
+        }
+        function parse(map) {
+          return typeof map === "string" ? JSON.parse(map) : map;
+        }
+        var FlattenMap = function (map, mapUrl) {
+          const parsed = parse(map);
+          if (!("sections" in parsed)) {
+            return new TraceMap(parsed, mapUrl);
+          }
+          const mappings = [];
+          const sources = [];
+          const sourcesContent = [];
+          const names = [];
+          const ignoreList = [];
+          recurse(
+            parsed,
+            mapUrl,
+            mappings,
+            sources,
+            sourcesContent,
+            names,
+            ignoreList,
+            0,
+            0,
+            Infinity,
+            Infinity,
+          );
+          const 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,
+        ) {
+          const { sections } = input;
+          for (let i = 0; i < sections.length; i++) {
+            const { map, offset } = sections[i];
+            let sl = stopLine;
+            let sc = stopColumn;
+            if (i + 1 < sections.length) {
+              const nextOffset = sections[i + 1].offset;
+              sl = Math.min(stopLine, lineOffset + nextOffset.line);
+              if (sl === stopLine) {
+                sc = Math.min(stopColumn, columnOffset + nextOffset.column);
+              } else if (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,
+        ) {
+          const parsed = parse(input);
+          if ("sections" in parsed) return recurse(...arguments);
+          const map = new TraceMap(parsed, mapUrl);
+          const sourcesOffset = sources.length;
+          const namesOffset = names.length;
+          const decoded = decodedMappings(map);
+          const {
+            resolvedSources,
+            sourcesContent: contents,
+            ignoreList: ignores,
+          } = map;
+          append(sources, resolvedSources);
+          append(names, map.names);
+          if (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++) {
+            const lineI = lineOffset + i;
+            if (lineI > stopLine) return;
+            const out = getLine(mappings, lineI);
+            const cOffset = i === 0 ? columnOffset : 0;
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+              const seg = line[j];
+              const column = cOffset + seg[COLUMN];
+              if (lineI === stopLine && column >= stopColumn) return;
+              if (seg.length === 1) {
+                out.push([column]);
+                continue;
+              }
+              const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
+              const sourceLine = seg[SOURCE_LINE];
+              const 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)";
+        var COL_GTR_EQ_ZERO =
+          "`column` must be greater than or equal to 0 (columns start at column 0)";
+        var LEAST_UPPER_BOUND = -1;
+        var GREATEST_LOWER_BOUND = 1;
+        var TraceMap = class {
+          constructor(map, mapUrl) {
+            const isString = typeof map === "string";
+            if (!isString && map._decodedMemo) return map;
+            const parsed = parse(map);
+            const {
+              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;
+            const resolve = resolver(mapUrl, sourceRoot);
+            this.resolvedSources = sources.map(resolve);
+            const { 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 if (parsed.sections) {
+              throw new Error(
+                `TraceMap passed sectioned source map, please use FlattenMap export instead`,
+              );
+            } else {
+              throw 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 = cast(map))._encoded) != null
+            ? _b
+            : (_a._encoded = (0, import_sourcemap_codec.encode)(
+                cast(map)._decoded,
+              ));
+        }
+        function decodedMappings(map) {
+          var _a;
+          return (
+            (_a = cast(map))._decoded ||
+            (_a._decoded = (0, import_sourcemap_codec.decode)(
+              cast(map)._encoded,
+            ))
+          );
+        }
+        function traceSegment(map, line, column) {
+          const decoded = decodedMappings(map);
+          if (line >= decoded.length) return null;
+          const segments = decoded[line];
+          const index = traceSegmentInternal(
+            segments,
+            cast(map)._decodedMemo,
+            line,
+            column,
+            GREATEST_LOWER_BOUND,
+          );
+          return index === -1 ? null : segments[index];
+        }
+        function originalPositionFor(map, needle) {
+          let { line, column, bias } = needle;
+          line--;
+          if (line < 0) throw new Error(LINE_GTR_ZERO);
+          if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+          const decoded = decodedMappings(map);
+          if (line >= decoded.length) return OMapping(null, null, null, null);
+          const segments = decoded[line];
+          const index = traceSegmentInternal(
+            segments,
+            cast(map)._decodedMemo,
+            line,
+            column,
+            bias || GREATEST_LOWER_BOUND,
+          );
+          if (index === -1) return OMapping(null, null, null, null);
+          const segment = segments[index];
+          if (segment.length === 1) return OMapping(null, null, null, null);
+          const { 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) {
+          const { source, line, column, bias } = needle;
+          return generatedPosition(
+            map,
+            source,
+            line,
+            column,
+            bias || GREATEST_LOWER_BOUND,
+            false,
+          );
+        }
+        function allGeneratedPositionsFor(map, needle) {
+          const { source, line, column, bias } = needle;
+          return generatedPosition(
+            map,
+            source,
+            line,
+            column,
+            bias || LEAST_UPPER_BOUND,
+            true,
+          );
+        }
+        function eachMapping(map, cb) {
+          const decoded = decodedMappings(map);
+          const { names, resolvedSources } = map;
+          for (let i = 0; i < decoded.length; i++) {
+            const line = decoded[i];
+            for (let j = 0; j < line.length; j++) {
+              const seg = line[j];
+              const generatedLine = i + 1;
+              const generatedColumn = seg[0];
+              let source = null;
+              let originalLine = null;
+              let originalColumn = null;
+              let name = null;
+              if (seg.length !== 1) {
+                source = resolvedSources[seg[1]];
+                originalLine = seg[2] + 1;
+                originalColumn = seg[3];
+              }
+              if (seg.length === 5) name = names[seg[4]];
+              cb({
+                generatedLine,
+                generatedColumn,
+                source,
+                originalLine,
+                originalColumn,
+                name,
+              });
+            }
+          }
+        }
+        function sourceIndex(map, source) {
+          const { sources, resolvedSources } = map;
+          let index = sources.indexOf(source);
+          if (index === -1) index = resolvedSources.indexOf(source);
+          return index;
+        }
+        function sourceContentFor(map, source) {
+          const { sourcesContent } = map;
+          if (sourcesContent == null) return null;
+          const index = sourceIndex(map, source);
+          return index === -1 ? null : sourcesContent[index];
+        }
+        function isIgnored(map, source) {
+          const { ignoreList } = map;
+          if (ignoreList == null) return false;
+          const index = sourceIndex(map, source);
+          return index === -1 ? false : ignoreList.includes(index);
+        }
+        function presortedDecodedMap(map, mapUrl) {
+          const tracer = new TraceMap(clone(map, []), mapUrl);
+          cast(tracer)._decoded = map.mappings;
+          return 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);
+          if (found) {
+            index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(
+              segments,
+              column,
+              index,
+            );
+          } else if (bias === LEAST_UPPER_BOUND) index++;
+          if (index === -1 || index === segments.length) return -1;
+          return 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++;
+          if (min === -1 || min === segments.length) return [];
+          const matchedColumn = found ? column : segments[min][COLUMN];
+          if (!found) min = lowerBound(segments, matchedColumn, min);
+          const max = upperBound(segments, matchedColumn, min);
+          const result = [];
+          for (; min <= max; min++) {
+            const 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;
+          line--;
+          if (line < 0) throw new Error(LINE_GTR_ZERO);
+          if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+          const { sources, resolvedSources } = map;
+          let sourceIndex2 = sources.indexOf(source);
+          if (sourceIndex2 === -1)
+            sourceIndex2 = resolvedSources.indexOf(source);
+          if (sourceIndex2 === -1) return all ? [] : GMapping(null, null);
+          const bySourceMemos =
+            (_a = cast(map))._bySourceMemos ||
+            (_a._bySourceMemos = sources.map(memoizedState));
+          const generated =
+            (_b = cast(map))._bySources ||
+            (_b._bySources = buildBySources(
+              decodedMappings(map),
+              bySourceMemos,
+            ));
+          const segments = generated[sourceIndex2][line];
+          if (segments == null) return all ? [] : GMapping(null, null);
+          const memo = bySourceMemos[sourceIndex2];
+          if (all)
+            return sliceGeneratedPositions(segments, memo, line, column, bias);
+          const index = traceSegmentInternal(
+            segments,
+            memo,
+            line,
+            column,
+            bias,
+          );
+          if (index === -1) return GMapping(null, null);
+          const segment = segments[index];
+          return GMapping(
+            segment[REV_GENERATED_LINE] + 1,
+            segment[REV_GENERATED_COLUMN],
+          );
+        }
+      });
+    },
+  };
+  var __webpack_module_cache__ = {};
+  function __nccwpck_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (cachedModule !== undefined) {
+      return cachedModule.exports;
+    }
+    var module = (__webpack_module_cache__[moduleId] = {
+      id: moduleId,
+      loaded: false,
+      exports: {},
+    });
+    var threw = true;
+    try {
+      __webpack_modules__[moduleId].call(
+        module.exports,
+        module,
+        module.exports,
+        __nccwpck_require__,
+      );
+      threw = false;
+    } finally {
+      if (threw) delete __webpack_module_cache__[moduleId];
+    }
+    module.loaded = true;
+    return module.exports;
+  }
+  (() => {
+    __nccwpck_require__.nmd = (module) => {
+      module.paths = [];
+      if (!module.children) module.children = [];
+      return module;
+    };
+  })();
+  if (typeof __nccwpck_require__ !== "undefined")
+    __nccwpck_require__.ab = __dirname + "/";
+  var __webpack_exports__ = __nccwpck_require__(118);
+  module.exports = __webpack_exports__;
+})();