vxrn 0.0.6 → 0.1.0

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/Symbolicator.native.js

@@ -0,0 +1,553 @@
+import { URL } from "url";
+import { codeFrameColumns } from "@babel/code-frame";
+import { SourceMapConsumer } from "source-map";
+function _array_like_to_array(arr, len) {
+  (len == null || len > arr.length) && (len = arr.length);
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _array_with_holes(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg), value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  info.done ? resolve(value) : Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+  return function() {
+    var self = this, args = arguments;
+    return new Promise(function(resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  return protoProps && _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), Constructor;
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+function _iterable_to_array_limit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol < "u" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i != null) {
+    var _arr = [], _n = !0, _d = !1, _s, _e;
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done) && (_arr.push(_s.value), !(i && _arr.length === i)); _n = !0)
+        ;
+    } catch (err) {
+      _d = !0, _e = err;
+    } finally {
+      try {
+        !_n && _i.return != null && _i.return();
+      } finally {
+        if (_d)
+          throw _e;
+      }
+    }
+    return _arr;
+  }
+}
+function _non_iterable_rest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {}, ownKeys2 = Object.keys(source);
+    typeof Object.getOwnPropertySymbols == "function" && (ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+    }))), ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  return source = source ?? {}, Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+    Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+  }), target;
+}
+function _sliced_to_array(arr, i) {
+  return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+  if (o) {
+    if (typeof o == "string")
+      return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor && (n = o.constructor.name), n === "Map" || n === "Set")
+      return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+      return _array_like_to_array(o, minLen);
+  }
+}
+function _ts_generator(thisArg, body) {
+  var f, y, t, g, _ = {
+    label: 0,
+    sent: function() {
+      if (t[0] & 1)
+        throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  };
+  return g = {
+    next: verb(0),
+    throw: verb(1),
+    return: verb(2)
+  }, typeof Symbol == "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([
+        n,
+        v
+      ]);
+    };
+  }
+  function step(op) {
+    if (f)
+      throw new TypeError("Generator is already executing.");
+    for (; _; )
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y.return : op[0] ? y.throw || ((t = y.return) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+          return t;
+        switch (y = 0, t && (op = [
+          op[0] & 2,
+          t.value
+        ]), op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+          case 4:
+            return _.label++, {
+              value: op[1],
+              done: !1
+            };
+          case 5:
+            _.label++, y = op[1], op = [
+              0
+            ];
+            continue;
+          case 7:
+            op = _.ops.pop(), _.trys.pop();
+            continue;
+          default:
+            if (t = _.trys, !(t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1], t = op;
+              break;
+            }
+            if (t && _.label < t[2]) {
+              _.label = t[2], _.ops.push(op);
+              break;
+            }
+            t[2] && _.ops.pop(), _.trys.pop();
+            continue;
+        }
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [
+          6,
+          e
+        ], y = 0;
+      } finally {
+        f = t = 0;
+      }
+    if (op[0] & 5)
+      throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: !0
+    };
+  }
+}
+var Symbolicator = /* @__PURE__ */ function() {
+  "use strict";
+  function Symbolicator2(delegate) {
+    _class_call_check(this, Symbolicator2), _define_property(this, "delegate", void 0), _define_property(this, "sourceMapConsumerCache", void 0), this.delegate = delegate, this.sourceMapConsumerCache = {};
+  }
+  return _create_class(Symbolicator2, [
+    {
+      key: "process",
+      value: (
+        /**
+        * Process raw React Native stack frames and transform them using Source Maps.
+        * Method will try to symbolicate as much data as possible, but if the Source Maps
+        * are not available, invalid or the original positions/data is not found in Source Maps,
+        * the method will return raw values - the same as supplied with `stack` parameter.
+        * For example out of 10 frames, it's possible that only first 7 will be symbolicated and the
+        * remaining 3 will be unchanged.
+        *
+        * @param logger Fastify logger instance.
+        * @param stack Raw stack frames.
+        * @returns Symbolicated stack frames.
+        */
+        function(logger, stack) {
+          var _this = this;
+          return _async_to_generator(function() {
+            var frames, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, frame, file, processedFrames, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, frame1, rawSourceMap, sourceMapConsumer, processedFrame, err, _ref, codeFrame, key;
+            return _ts_generator(this, function(_state) {
+              switch (_state.label) {
+                case 0:
+                  logger.debug({
+                    msg: "Filtering out unnecessary frames"
+                  }), frames = [], _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+                  try {
+                    for (_iterator = stack[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0)
+                      frame = _step.value, file = frame.file, file != null && file.startsWith("http") && !file.includes("debuggerWorker") && frames.push(frame);
+                  } catch (err2) {
+                    _didIteratorError = !0, _iteratorError = err2;
+                  } finally {
+                    try {
+                      !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                    } finally {
+                      if (_didIteratorError)
+                        throw _iteratorError;
+                    }
+                  }
+                  _state.label = 1;
+                case 1:
+                  _state.trys.push([
+                    1,
+                    ,
+                    13,
+                    14
+                  ]), logger.debug({
+                    msg: "Processing frames",
+                    frames
+                  }), processedFrames = [], _iteratorNormalCompletion1 = !0, _didIteratorError1 = !1, _iteratorError1 = void 0, _state.label = 2;
+                case 2:
+                  _state.trys.push([
+                    2,
+                    9,
+                    10,
+                    11
+                  ]), _iterator1 = frames[Symbol.iterator](), _state.label = 3;
+                case 3:
+                  return (_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done) ? [
+                    3,
+                    8
+                  ] : (frame1 = _step1.value, _this.sourceMapConsumerCache[frame1.file] ? [
+                    3,
+                    6
+                  ] : (logger.debug({
+                    msg: "Loading raw source map data",
+                    fileUrl: frame1.file
+                  }), [
+                    4,
+                    _this.delegate.getSourceMap(frame1.file)
+                  ]));
+                case 4:
+                  return rawSourceMap = _state.sent(), logger.debug({
+                    msg: "Creating source map instance",
+                    fileUrl: frame1.file,
+                    sourceMapLength: rawSourceMap.length
+                  }), [
+                    4,
+                    new SourceMapConsumer(rawSourceMap.toString())
+                  ];
+                case 5:
+                  sourceMapConsumer = _state.sent(), logger.debug({
+                    msg: "Saving source map instance into cache",
+                    fileUrl: frame1.file
+                  }), _this.sourceMapConsumerCache[frame1.file] = sourceMapConsumer, _state.label = 6;
+                case 6:
+                  logger.debug({
+                    msg: "Symbolicating frame",
+                    frame: frame1
+                  }), processedFrame = _this.processFrame(frame1), logger.debug({
+                    msg: "Finished symbolicating frame",
+                    frame: frame1
+                  }), processedFrames.push(processedFrame), _state.label = 7;
+                case 7:
+                  return _iteratorNormalCompletion1 = !0, [
+                    3,
+                    3
+                  ];
+                case 8:
+                  return [
+                    3,
+                    11
+                  ];
+                case 9:
+                  return err = _state.sent(), _didIteratorError1 = !0, _iteratorError1 = err, [
+                    3,
+                    11
+                  ];
+                case 10:
+                  try {
+                    !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+                  } finally {
+                    if (_didIteratorError1)
+                      throw _iteratorError1;
+                  }
+                  return [
+                    7
+                  ];
+                case 11:
+                  return [
+                    4,
+                    _this.getCodeFrame(logger, processedFrames)
+                  ];
+                case 12:
+                  return codeFrame = (_ref = _state.sent()) !== null && _ref !== void 0 ? _ref : null, logger.debug({
+                    msg: "Finished symbolicating frames",
+                    processedFrames,
+                    codeFrame
+                  }), [
+                    2,
+                    {
+                      stack: processedFrames,
+                      codeFrame
+                    }
+                  ];
+                case 13:
+                  for (var key2 in _this.sourceMapConsumerCache)
+                    _this.sourceMapConsumerCache[key2].destroy(), delete _this.sourceMapConsumerCache[key2];
+                  return [
+                    7
+                  ];
+                case 14:
+                  return [
+                    2
+                  ];
+              }
+            });
+          })();
+        }
+      )
+    },
+    {
+      key: "processFrame",
+      value: function(frame) {
+        if (!frame.lineNumber || !frame.column)
+          return _object_spread_props(_object_spread({}, frame), {
+            collapse: !1
+          });
+        var consumer = this.sourceMapConsumerCache[frame.file];
+        if (!consumer)
+          return _object_spread_props(_object_spread({}, frame), {
+            collapse: !1
+          });
+        var lookup = consumer.originalPositionFor({
+          line: frame.lineNumber,
+          column: frame.column
+        });
+        return lookup.source ? {
+          lineNumber: lookup.line || frame.lineNumber,
+          column: lookup.column || frame.column,
+          file: lookup.source,
+          methodName: lookup.name || frame.methodName,
+          collapse: !1
+        } : _object_spread_props(_object_spread({}, frame), {
+          collapse: !1
+        });
+      }
+    },
+    {
+      key: "getCodeFrame",
+      value: function(logger, processedFrames) {
+        var _this = this;
+        return _async_to_generator(function() {
+          var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, frame, _tmp, error, err;
+          return _ts_generator(this, function(_state) {
+            switch (_state.label) {
+              case 0:
+                _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0, _state.label = 1;
+              case 1:
+                _state.trys.push([
+                  1,
+                  9,
+                  10,
+                  11
+                ]), _iterator = processedFrames[Symbol.iterator](), _state.label = 2;
+              case 2:
+                if (_iteratorNormalCompletion = (_step = _iterator.next()).done)
+                  return [
+                    3,
+                    8
+                  ];
+                if (frame = _step.value, frame.collapse || !frame.lineNumber || !frame.column)
+                  return [
+                    3,
+                    7
+                  ];
+                if (!_this.delegate.shouldIncludeFrame(frame))
+                  return [
+                    2,
+                    void 0
+                  ];
+                logger.debug({
+                  msg: "Generating code frame",
+                  frame
+                }), _state.label = 3;
+              case 3:
+                return _state.trys.push([
+                  3,
+                  5,
+                  ,
+                  6
+                ]), _tmp = {}, [
+                  4,
+                  _this.delegate.getSource(frame.file)
+                ];
+              case 4:
+                return [
+                  2,
+                  (_tmp.content = codeFrameColumns.apply(void 0, [
+                    _state.sent().toString(),
+                    {
+                      start: {
+                        column: frame.column,
+                        line: frame.lineNumber
+                      }
+                    },
+                    {
+                      forceColor: !0
+                    }
+                  ]), _tmp.location = {
+                    row: frame.lineNumber,
+                    column: frame.column
+                  }, _tmp.fileName = frame.file, _tmp)
+                ];
+              case 5:
+                return error = _state.sent(), logger.error({
+                  msg: "Failed to create code frame",
+                  error: error.message
+                }), [
+                  3,
+                  6
+                ];
+              case 6:
+                return [
+                  2,
+                  void 0
+                ];
+              case 7:
+                return _iteratorNormalCompletion = !0, [
+                  3,
+                  2
+                ];
+              case 8:
+                return [
+                  3,
+                  11
+                ];
+              case 9:
+                return err = _state.sent(), _didIteratorError = !0, _iteratorError = err, [
+                  3,
+                  11
+                ];
+              case 10:
+                try {
+                  !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+                } finally {
+                  if (_didIteratorError)
+                    throw _iteratorError;
+                }
+                return [
+                  7
+                ];
+              case 11:
+                return [
+                  2
+                ];
+            }
+          });
+        })();
+      }
+    }
+  ], [
+    {
+      key: "inferPlatformFromStack",
+      value: (
+        /**
+        * Infer platform from stack frames.
+        * Usually at least one frame has `file` field with the bundle URL eg:
+        * `http://localhost:8081/index.bundle?platform=ios&...`, which can be used to infer platform.
+        *
+        * @param stack Array of stack frames.
+        * @returns Inferred platform or `undefined` if cannot infer.
+        */
+        function(stack) {
+          var _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+          try {
+            for (var _iterator = stack[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+              var frame = _step.value;
+              if (!frame.file)
+                return;
+              var _ref = new URL(frame.file, "file://"), searchParams = _ref.searchParams, pathname = _ref.pathname, platform = searchParams.get("platform");
+              if (platform)
+                return platform;
+              var _pathname_split_reverse = _sliced_to_array(pathname.split("/").reverse(), 1), bundleFilename = _pathname_split_reverse[0], _bundleFilename_split = _sliced_to_array(bundleFilename.split("."), 3), platformOrExtension = _bundleFilename_split[1], extension = _bundleFilename_split[2];
+              if (extension)
+                return platformOrExtension;
+            }
+          } catch (err) {
+            _didIteratorError = !0, _iteratorError = err;
+          } finally {
+            try {
+              !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+            } finally {
+              if (_didIteratorError)
+                throw _iteratorError;
+            }
+          }
+        }
+      )
+    }
+  ]), Symbolicator2;
+}();
+export {
+  Symbolicator
+};
+//# sourceMappingURL=Symbolicator.js.map

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/Symbolicator.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../src/vendor/repack/dev-server/src/plugins/symbolicate/Users/n8/vxrn/packages/vxrn/src/vendor/repack/dev-server/src/plugins/symbolicate/Symbolicator.ts"],
+  "mappings": "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",
+  "names": ["URL", "codeFrameColumns", "SourceMapConsumer", "Symbolicator", "delegate", "sourceMapConsumerCache", "process", "logger", "stack", "frames", "frame", "file", "processedFrames", "rawSourceMap", "sourceMapConsumer", "processedFrame", "codeFrame", "key", "debug", "msg", "startsWith", "includes", "push", "err", "fileUrl", "getSourceMap", "sourceMapLength", "length", "toString", "processFrame", "getCodeFrame", "destroy", "lineNumber", "column", "collapse", "consumer", "lookup", "originalPositionFor", "line", "source", "methodName", "name", "error", "shouldIncludeFrame", "undefined", "getSource", "content", "start", "forceColor", "location", "row", "fileName", "message", "inferPlatformFromStack", "searchParams", "pathname", "platform", "get", "split", "reverse", "bundleFilename", "platformOrExtension", "extension"]
+}

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/index.js

@@ -0,0 +1,7 @@
+import { default as default2 } from "./sybmolicatePlugin";
+export * from "./Symbolicator";
+export * from "./types";
+export {
+  default2 as default
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../src/vendor/repack/dev-server/src/plugins/symbolicate/index.ts"],
+  "mappings": "AAAA,SAAS,WAAAA,gBAAe;AACxB,cAAc;AACd,cAAc;",
+  "names": ["default"]
+}

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/index.mjs

@@ -0,0 +1,4 @@
+import { default as default2 } from "./sybmolicatePlugin.mjs";
+export * from "./Symbolicator.mjs";
+export * from "./types.mjs";
+export { default2 as default };

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/index.native.js

@@ -0,0 +1,7 @@
+import { default as default2 } from "./sybmolicatePlugin";
+export * from "./Symbolicator";
+export * from "./types";
+export {
+  default2 as default
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/index.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../src/vendor/repack/dev-server/src/plugins/symbolicate/Users/n8/vxrn/packages/vxrn/src/vendor/repack/dev-server/src/plugins/symbolicate/index.ts"],
+  "mappings": "AAAA,SAASA,WAAAA,gBAAe;AACxB,cAAc;AACd,cAAc;",
+  "names": ["default"]
+}

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/sybmolicatePlugin.js

@@ -0,0 +1,32 @@
+import fastifyPlugin from "fastify-plugin";
+import { Symbolicator } from "./Symbolicator";
+async function symbolicatePlugin(instance, {
+  delegate
+}) {
+  const symbolicator = new Symbolicator(delegate.symbolicator);
+  instance.post("/symbolicate", async (request, reply) => {
+    try {
+      const { stack } = JSON.parse(request.body), platform = Symbolicator.inferPlatformFromStack(stack);
+      if (!platform)
+        request.log.debug({ msg: "Received stack", stack }), reply.badRequest("Cannot infer platform from stack trace");
+      else {
+        request.log.debug({ msg: "Starting symbolication", platform, stack });
+        const results = await symbolicator.process(request.log, stack);
+        reply.send(results);
+      }
+    } catch (error) {
+      request.log.error({
+        msg: "Failed to symbolicate",
+        error: error.message
+      }), reply.internalServerError();
+    }
+  });
+}
+var sybmolicatePlugin_default = fastifyPlugin(symbolicatePlugin, {
+  name: "symbolicate-plugin",
+  dependencies: ["fastify-sensible"]
+});
+export {
+  sybmolicatePlugin_default as default
+};
+//# sourceMappingURL=sybmolicatePlugin.js.map

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/sybmolicatePlugin.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../src/vendor/repack/dev-server/src/plugins/symbolicate/sybmolicatePlugin.ts"],
+  "mappings": "AACA,OAAO,mBAAmB;AAG1B,SAAS,oBAAoB;AAG7B,eAAe,kBACb,UACA;AAAA,EACE;AACF,GAGA;AACA,QAAM,eAAe,IAAI,aAAa,SAAS,YAAY;AAE3D,WAAS,KAAK,gBAAgB,OAAO,SAAS,UAAU;AAItD,QAAI;AACF,YAAM,EAAE,MAAM,IAAI,KAAK,MAAM,QAAQ,IAAc,GAG7C,WAAW,aAAa,uBAAuB,KAAK;AAC1D,UAAI,CAAC;AACH,gBAAQ,IAAI,MAAM,EAAE,KAAK,kBAAkB,MAAM,CAAC,GAClD,MAAM,WAAW,wCAAwC;AAAA,WACpD;AACL,gBAAQ,IAAI,MAAM,EAAE,KAAK,0BAA0B,UAAU,MAAM,CAAC;AACpE,cAAM,UAAU,MAAM,aAAa,QAAQ,QAAQ,KAAK,KAAK;AAC7D,cAAM,KAAK,OAAO;AAAA,MACpB;AAAA,IACF,SAAS,OAAO;AACd,cAAQ,IAAI,MAAM;AAAA,QAChB,KAAK;AAAA,QACL,OAAQ,MAAgB;AAAA,MAC1B,CAAC,GACD,MAAM,oBAAoB;AAAA,IAC5B;AAAA,EACF,CAAC;AACH;AAEA,IAAO,4BAAQ,cAAc,mBAAmB;AAAA,EAC9C,MAAM;AAAA,EACN,cAAc,CAAC,kBAAkB;AACnC,CAAC;",
+  "names": []
+}

package/dist/esm/vendor/repack/dev-server/src/plugins/symbolicate/sybmolicatePlugin.mjs

@@ -0,0 +1,37 @@
+import fastifyPlugin from "fastify-plugin";
+import { Symbolicator } from "./Symbolicator.mjs";
+async function symbolicatePlugin(instance, {
+  delegate
+}) {
+  const symbolicator = new Symbolicator(delegate.symbolicator);
+  instance.post("/symbolicate", async (request, reply) => {
+    try {
+      const {
+          stack
+        } = JSON.parse(request.body),
+        platform = Symbolicator.inferPlatformFromStack(stack);
+      if (!platform) request.log.debug({
+        msg: "Received stack",
+        stack
+      }), reply.badRequest("Cannot infer platform from stack trace");else {
+        request.log.debug({
+          msg: "Starting symbolication",
+          platform,
+          stack
+        });
+        const results = await symbolicator.process(request.log, stack);
+        reply.send(results);
+      }
+    } catch (error) {
+      request.log.error({
+        msg: "Failed to symbolicate",
+        error: error.message
+      }), reply.internalServerError();
+    }
+  });
+}
+var sybmolicatePlugin_default = fastifyPlugin(symbolicatePlugin, {
+  name: "symbolicate-plugin",
+  dependencies: ["fastify-sensible"]
+});
+export { sybmolicatePlugin_default as default };