@lvce-editor/pty-host 4.2.0 → 5.1.0

package/dist/ptyHostMain.js

@@ -1,14 +1,1116 @@
-import { register, execute } from '@lvce-editor/command';
-import { IpcChildWithWebSocket, IpcChildWithElectronMessagePort, IpcChildWithElectronUtilityProcess, IpcChildWithNodeForkedProcess } from '@lvce-editor/ipc';
-import * as JsonRpc from '@lvce-editor/json-rpc';
-import { handleJsonRpcMessage, resolve } from '@lvce-editor/json-rpc';
 import debugModule from 'debug';
 import { spawn } from 'node-pty';
-import { VError } from '@lvce-editor/verror';
 import { Console } from 'node:console';
-import { createWriteStream } from 'node:fs';
+import { createWriteStream, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { prepare } from '@lvce-editor/pretty-error';
+import { fileURLToPath } from 'node:url';
+import { Buffer } from 'node:buffer';
+
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$4 = '\n';
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$4, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$2(parent);
+  const childNewLineIndex = getNewLineIndex$2(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String$1 = 4;
+const Boolean = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean;
+    default:
+      return Unknown;
+  }
+};
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const array = value => {
+  const type = getType(value);
+  if (type !== Array$1) {
+    throw new AssertionError('expected value to be of type array');
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== String$1) {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const removeValues = (value, toRemove) => {
+  if (!value) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const newItems = [];
+    for (const item of value) {
+      if (!toRemove.includes(item)) {
+        newItems.push(removeValues(item, toRemove));
+      }
+    }
+    return newItems;
+  }
+  if (typeof value === 'object') {
+    const newObject = Object.create(null);
+    for (const [key, property] of Object.entries(value)) {
+      if (!toRemove.includes(property)) {
+        newObject[key] = removeValues(property, toRemove);
+      }
+    }
+    return newObject;
+  }
+  return value;
+};
+
+// workaround for electron not supporting transferrable objects
+// as parameters. If the transferrable object is a parameter, in electron
+// only an empty objected is received in the main process
+const fixElectronParameters = value => {
+  const transfer = getTransferrables(value);
+  const newValue = removeValues(value, transfer);
+  return {
+    newValue,
+    transfer
+  };
+};
+const getActualDataElectron = event => {
+  const {
+    data,
+    ports
+  } = event;
+  if (ports.length === 0) {
+    return data;
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params]
+  };
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND$1 = 'ERR_MODULE_NOT_FOUND';
+const NewLine$3 = '\n';
+const joinLines$2 = lines => {
+  return lines.join(NewLine$3);
+};
+const RE_AT$1 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine$1 = line => {
+  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line);
+};
+const getDetails$1 = lines => {
+  const index = lines.findIndex(isNormalStackLine$1);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$2(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine$1(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+const splitLines$2 = lines => {
+  return lines.split(NewLine$3);
+};
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$2(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$2(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND$1
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$2(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails$1(lines);
+  return {
+    message: actualMessage,
+    code: '',
+    stack: rest
+  };
+};
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        message,
+        code,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+}
+const listen$b = ({
+  messagePort
+}) => {
+  if (!isMessagePortMain(messagePort)) {
+    throw new IpcError('port must be of type MessagePortMain');
+  }
+  return messagePort;
+};
+const signal$c = messagePort => {
+  messagePort.start();
+};
+class IpcChildWithElectronMessagePort extends Ipc {
+  getData = getActualDataElectron;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+}
+const wrap$j = messagePort => {
+  return new IpcChildWithElectronMessagePort(messagePort);
+};
+const IpcChildWithElectronMessagePort$1 = {
+  __proto__: null,
+  listen: listen$b,
+  signal: signal$c,
+  wrap: wrap$j
+};
+
+// @ts-ignore
+const getUtilityProcessPortData = event => {
+  const {
+    data,
+    ports
+  } = event;
+  if (ports.length === 0) {
+    return data;
+  }
+  return {
+    ...data,
+    params: [...ports, ...data.params]
+  };
+};
+const readyMessage = 'ready';
+const listen$a = () => {
+  // @ts-ignore
+  const {
+    parentPort
+  } = process;
+  if (!parentPort) {
+    throw new Error('parent port must be defined');
+  }
+  return parentPort;
+};
+const signal$b = parentPort => {
+  parentPort.postMessage(readyMessage);
+};
+class IpcChildWithElectronUtilityProcess extends Ipc {
+  getData(event) {
+    return getUtilityProcessPortData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const {
+      newValue,
+      transfer
+    } = fixElectronParameters(message);
+    this._rawIpc.postMessage(newValue, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+}
+const wrap$i = parentPort => {
+  return new IpcChildWithElectronUtilityProcess(parentPort);
+};
+const IpcChildWithElectronUtilityProcess$1 = {
+  __proto__: null,
+  listen: listen$a,
+  signal: signal$b,
+  wrap: wrap$i
+};
+const getActualData = (message, handle) => {
+  if (handle) {
+    return {
+      ...message,
+      params: [handle, ...message.params]
+    };
+  }
+  return message;
+};
+const getTransferrablesNode = value => {
+  const transferrables = getTransferrables(value);
+  if (transferrables.length === 0) {
+    throw new Error(`no transferrables found`);
+  }
+  return transferrables[0];
+};
+const listen$5 = async () => {
+  if (!process.send) {
+    throw new Error('process.send must be defined');
+  }
+  return process;
+};
+const signal$7 = process => {
+  process.send(readyMessage);
+};
+class IpcChildWithNodeForkedProcess extends Ipc {
+  getData(message, handle) {
+    return getActualData(message, handle);
+  }
+  onClose(callback) {
+    this._rawIpc.on('close', callback);
+  }
+  send(message) {
+    this._rawIpc.send(message);
+  }
+  onMessage(callback) {
+    this._rawIpc.on('message', callback);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrablesNode(message);
+    this._rawIpc.send(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+}
+const wrap$d = process => {
+  return new IpcChildWithNodeForkedProcess(process);
+};
+const IpcChildWithNodeForkedProcess$1 = {
+  __proto__: null,
+  listen: listen$5,
+  signal: signal$7,
+  wrap: wrap$d
+};
+const Open = 2;
+const Close = 3;
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+
+// @ts-ignore
+const getFirstWebSocketEvent = async webSocket => {
+  // @ts-ignore
+  const {
+    WebSocket
+  } = await import('ws');
+  switch (webSocket.readyState) {
+    case WebSocket.OPEN:
+      return {
+        type: Open,
+        event: undefined
+      };
+    case WebSocket.CLOSED:
+      return {
+        type: Close,
+        event: undefined
+      };
+  }
+  // @ts-ignore
+  const {
+    type,
+    event
+  } = await getFirstEvent(webSocket, {
+    open: Open,
+    close: Close
+  });
+  return {
+    type,
+    event
+  };
+};
+
+// @ts-ignore
+const isWebSocketOpen = async webSocket => {
+  // @ts-ignore
+  const {
+    WebSocket
+  } = await import('ws');
+  return webSocket.readyState === WebSocket.OPEN;
+};
+
+// @ts-ignore
+const serialize = message => {
+  return JSON.stringify(message);
+};
+
+// @ts-ignore
+const deserialize = message => {
+  return JSON.parse(message.toString());
+};
+
+// @ts-ignore
+const handleUpgrade$1 = async (...args) => {
+  const module = await Promise.resolve().then(function () { return index; });
+  // @ts-ignore
+  return module.handleUpgrade(...args);
+};
+const listen$1$1 = async ({
+  request,
+  handle
+}) => {
+  if (!request) {
+    throw new IpcError('request must be defined');
+  }
+  if (!handle) {
+    throw new IpcError('handle must be defined');
+  }
+  const webSocket = await handleUpgrade$1(request, handle);
+  webSocket.pause();
+  if (!(await isWebSocketOpen(webSocket))) {
+    await getFirstWebSocketEvent(webSocket);
+  }
+  return webSocket;
+};
+const signal$4 = webSocket => {
+  webSocket.resume();
+};
+const wrap$9 = webSocket => {
+  return {
+    webSocket,
+    /**
+     * @type {any}
+     */
+    wrappedListener: undefined,
+    // @ts-ignore
+    on(event, listener) {
+      switch (event) {
+        case 'message':
+          // @ts-ignore
+          const wrappedListener = message => {
+            const data = deserialize(message);
+            const event = {
+              data,
+              target: this
+            };
+            listener(event);
+          };
+          webSocket.on('message', wrappedListener);
+          break;
+        case 'close':
+          webSocket.on('close', listener);
+          break;
+        default:
+          throw new Error('unknown event listener type');
+      }
+    },
+    // @ts-ignore
+    off(event, listener) {
+      this.webSocket.off(event, listener);
+    },
+    // @ts-ignore
+    send(message) {
+      const stringifiedMessage = serialize(message);
+      this.webSocket.send(stringifiedMessage);
+    },
+    dispose() {
+      this.webSocket.close();
+    },
+    start() {
+      throw new Error('start method is deprecated');
+    }
+  };
+};
+const IpcChildWithWebSocket = {
+  __proto__: null,
+  listen: listen$1$1,
+  signal: signal$4,
+  wrap: wrap$9
+};
+
+const Two = '2.0';
+const create$4 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const callbacks = Object.create(null);
+const set$1 = (id, fn) => {
+  callbacks[id] = fn;
+};
+const get$1 = id => {
+  return callbacks[id];
+};
+const remove$1 = id => {
+  delete callbacks[id];
+};
+let id = 0;
+const create$3 = () => {
+  return ++id;
+};
+const registerPromise = () => {
+  const id = create$3();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$1(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
+const create$2 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+const NewLine$2 = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const joinLines$1 = lines => {
+  return lines.join(NewLine$2);
+};
+const splitLines$1 = lines => {
+  return lines.split(NewLine$2);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$2 + parentStack;
+  }
+  return parentStack;
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine$2 + currentStack;
+    }
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine$2 + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$2 + error.data.stack + NewLine$2 + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex$1(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const warn$1 = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$1(id);
+  if (!fn) {
+    console.log(response);
+    warn$1(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove$1(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      message: error.message,
+      data: error.stack
+    };
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: getStack(prettyError),
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$1 = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$5 = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$5(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
+  }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const send = (transport, method, ...params) => {
+  const message = create$4(method, params);
+  transport.send(message);
+};
+const invoke = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
+};
 
 const createRpc = ipc => {
   const rpc = {
@@ -18,13 +1120,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      JsonRpc.send(ipc, method, ...params);
+      send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return JsonRpc.invoke(ipc, method, ...params);
+      return invoke(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return JsonRpc.invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -62,14 +1164,14 @@ const listen$2 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$e = async ({
+const create$k = async ({
   commandMap,
   messagePort,
   requiresSocket
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronMessagePort, {
+  const ipc = await listen$2(IpcChildWithElectronMessagePort$1, {
     messagePort
   });
   if (requiresSocket) {
@@ -81,37 +1183,37 @@ const create$e = async ({
 };
 const ElectronMessagePortRpcClient = {
   __proto__: null,
-  create: create$e
+  create: create$k
 };
-const create$d = async ({
+const create$j = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithElectronUtilityProcess);
+  const ipc = await listen$2(IpcChildWithElectronUtilityProcess$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 const ElectronUtilityProcessRpcClient = {
   __proto__: null,
-  create: create$d
+  create: create$j
 };
-const create$7 = async ({
+const create$a = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$2(IpcChildWithNodeForkedProcess);
+  const ipc = await listen$2(IpcChildWithNodeForkedProcess$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 const NodeForkedProcessRpcClient = {
   __proto__: null,
-  create: create$7
+  create: create$a
 };
-const create$5 = async ({
+const create$8 = async ({
   commandMap,
   request,
   handle,
@@ -132,60 +1234,7 @@ const create$5 = async ({
 };
 const NodeWebSocketRpcClient = {
   __proto__: null,
-  create: create$5
-};
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const object = value => {
-  const type = getType(value);
-  if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const array = value => {
-  const type = getType(value);
-  if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
-  }
+  create: create$8
 };
 
 const METHODS_THAT_REQUIRE_SOCKET = new Set(['Terminal.create']);
@@ -422,7 +1471,7 @@ const listen = async () => {
   });
 };
 
-const NewLine = '\n';
+const NewLine$1 = '\n';
 
 const Error$1 = 1;
 const Success = 0;
@@ -434,7 +1483,7 @@ const Success = 0;
  * @returns
  */
 const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+  return string.indexOf(NewLine$1, startIndex);
 };
 
 const EPIPE = 'EPIPE';
@@ -490,6 +1539,722 @@ const error = (...args) => {
   console.error(...args);
 };
 
+var lib$1 = {};
+
+var picocolors = {exports: {}};
+
+var hasRequiredPicocolors;
+
+function requirePicocolors () {
+	if (hasRequiredPicocolors) return picocolors.exports;
+	hasRequiredPicocolors = 1;
+	let p = process || {},
+	  argv = p.argv || [],
+	  env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => input => {
+	  let string = "" + input,
+	    index = string.indexOf(close, open.length);
+	  return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+	  let result = "",
+	    cursor = 0;
+	  do {
+	    result += string.substring(cursor, index) + replace;
+	    cursor = index + close.length;
+	    index = string.indexOf(close, cursor);
+	  } while (~index);
+	  return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+	  let f = enabled ? formatter : () => String;
+	  return {
+	    isColorSupported: enabled,
+	    reset: f("\x1b[0m", "\x1b[0m"),
+	    bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
+	    dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
+	    italic: f("\x1b[3m", "\x1b[23m"),
+	    underline: f("\x1b[4m", "\x1b[24m"),
+	    inverse: f("\x1b[7m", "\x1b[27m"),
+	    hidden: f("\x1b[8m", "\x1b[28m"),
+	    strikethrough: f("\x1b[9m", "\x1b[29m"),
+	    black: f("\x1b[30m", "\x1b[39m"),
+	    red: f("\x1b[31m", "\x1b[39m"),
+	    green: f("\x1b[32m", "\x1b[39m"),
+	    yellow: f("\x1b[33m", "\x1b[39m"),
+	    blue: f("\x1b[34m", "\x1b[39m"),
+	    magenta: f("\x1b[35m", "\x1b[39m"),
+	    cyan: f("\x1b[36m", "\x1b[39m"),
+	    white: f("\x1b[37m", "\x1b[39m"),
+	    gray: f("\x1b[90m", "\x1b[39m"),
+	    bgBlack: f("\x1b[40m", "\x1b[49m"),
+	    bgRed: f("\x1b[41m", "\x1b[49m"),
+	    bgGreen: f("\x1b[42m", "\x1b[49m"),
+	    bgYellow: f("\x1b[43m", "\x1b[49m"),
+	    bgBlue: f("\x1b[44m", "\x1b[49m"),
+	    bgMagenta: f("\x1b[45m", "\x1b[49m"),
+	    bgCyan: f("\x1b[46m", "\x1b[49m"),
+	    bgWhite: f("\x1b[47m", "\x1b[49m"),
+	    blackBright: f("\x1b[90m", "\x1b[39m"),
+	    redBright: f("\x1b[91m", "\x1b[39m"),
+	    greenBright: f("\x1b[92m", "\x1b[39m"),
+	    yellowBright: f("\x1b[93m", "\x1b[39m"),
+	    blueBright: f("\x1b[94m", "\x1b[39m"),
+	    magentaBright: f("\x1b[95m", "\x1b[39m"),
+	    cyanBright: f("\x1b[96m", "\x1b[39m"),
+	    whiteBright: f("\x1b[97m", "\x1b[39m"),
+	    bgBlackBright: f("\x1b[100m", "\x1b[49m"),
+	    bgRedBright: f("\x1b[101m", "\x1b[49m"),
+	    bgGreenBright: f("\x1b[102m", "\x1b[49m"),
+	    bgYellowBright: f("\x1b[103m", "\x1b[49m"),
+	    bgBlueBright: f("\x1b[104m", "\x1b[49m"),
+	    bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
+	    bgCyanBright: f("\x1b[106m", "\x1b[49m"),
+	    bgWhiteBright: f("\x1b[107m", "\x1b[49m")
+	  };
+	};
+	picocolors.exports = createColors();
+	picocolors.exports.createColors = createColors;
+	return picocolors.exports;
+}
+
+var jsTokens = {};
+
+var hasRequiredJsTokens;
+
+function requireJsTokens () {
+	if (hasRequiredJsTokens) return jsTokens;
+	hasRequiredJsTokens = 1;
+	// Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell
+	// License: MIT. (See LICENSE.)
+
+	Object.defineProperty(jsTokens, "__esModule", {
+	  value: true
+	});
+
+	// This regex comes from regex.coffee, and is inserted here by generate-index.js
+	// (run `npm run build`).
+	jsTokens.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g;
+	jsTokens.matchToToken = function (match) {
+	  var token = {
+	    type: "invalid",
+	    value: match[0],
+	    closed: undefined
+	  };
+	  if (match[1]) token.type = "string", token.closed = !!(match[3] || match[4]);else if (match[5]) token.type = "comment";else if (match[6]) token.type = "comment", token.closed = !!match[7];else if (match[8]) token.type = "regex";else if (match[9]) token.type = "number";else if (match[10]) token.type = "name";else if (match[11]) token.type = "punctuator";else if (match[12]) token.type = "whitespace";
+	  return token;
+	};
+	return jsTokens;
+}
+
+var lib = {};
+
+var identifier = {};
+
+var hasRequiredIdentifier;
+
+function requireIdentifier () {
+	if (hasRequiredIdentifier) return identifier;
+	hasRequiredIdentifier = 1;
+
+	Object.defineProperty(identifier, "__esModule", {
+	  value: true
+	});
+	identifier.isIdentifierChar = isIdentifierChar;
+	identifier.isIdentifierName = isIdentifierName;
+	identifier.isIdentifierStart = isIdentifierStart;
+	let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+	let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+	const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+	const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+	nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+	const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7, 221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191];
+	const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+	function isInAstralSet(code, set) {
+	  let pos = 0x10000;
+	  for (let i = 0, length = set.length; i < length; i += 2) {
+	    pos += set[i];
+	    if (pos > code) return false;
+	    pos += set[i + 1];
+	    if (pos >= code) return true;
+	  }
+	  return false;
+	}
+	function isIdentifierStart(code) {
+	  if (code < 65) return code === 36;
+	  if (code <= 90) return true;
+	  if (code < 97) return code === 95;
+	  if (code <= 122) return true;
+	  if (code <= 0xffff) {
+	    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+	  }
+	  return isInAstralSet(code, astralIdentifierStartCodes);
+	}
+	function isIdentifierChar(code) {
+	  if (code < 48) return code === 36;
+	  if (code < 58) return true;
+	  if (code < 65) return false;
+	  if (code <= 90) return true;
+	  if (code < 97) return code === 95;
+	  if (code <= 122) return true;
+	  if (code <= 0xffff) {
+	    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+	  }
+	  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+	}
+	function isIdentifierName(name) {
+	  let isFirst = true;
+	  for (let i = 0; i < name.length; i++) {
+	    let cp = name.charCodeAt(i);
+	    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+	      const trail = name.charCodeAt(++i);
+	      if ((trail & 0xfc00) === 0xdc00) {
+	        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+	      }
+	    }
+	    if (isFirst) {
+	      isFirst = false;
+	      if (!isIdentifierStart(cp)) {
+	        return false;
+	      }
+	    } else if (!isIdentifierChar(cp)) {
+	      return false;
+	    }
+	  }
+	  return !isFirst;
+	}
+	return identifier;
+}
+
+var keyword = {};
+
+var hasRequiredKeyword;
+
+function requireKeyword () {
+	if (hasRequiredKeyword) return keyword;
+	hasRequiredKeyword = 1;
+
+	Object.defineProperty(keyword, "__esModule", {
+	  value: true
+	});
+	keyword.isKeyword = isKeyword;
+	keyword.isReservedWord = isReservedWord;
+	keyword.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+	keyword.isStrictBindReservedWord = isStrictBindReservedWord;
+	keyword.isStrictReservedWord = isStrictReservedWord;
+	const reservedWords = {
+	  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+	  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+	  strictBind: ["eval", "arguments"]
+	};
+	const keywords = new Set(reservedWords.keyword);
+	const reservedWordsStrictSet = new Set(reservedWords.strict);
+	const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+	function isReservedWord(word, inModule) {
+	  return inModule && word === "await" || word === "enum";
+	}
+	function isStrictReservedWord(word, inModule) {
+	  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+	}
+	function isStrictBindOnlyReservedWord(word) {
+	  return reservedWordsStrictBindSet.has(word);
+	}
+	function isStrictBindReservedWord(word, inModule) {
+	  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+	}
+	function isKeyword(word) {
+	  return keywords.has(word);
+	}
+	return keyword;
+}
+
+var hasRequiredLib$1;
+
+function requireLib$1 () {
+	if (hasRequiredLib$1) return lib;
+	hasRequiredLib$1 = 1;
+	(function (exports) {
+
+		Object.defineProperty(exports, "__esModule", {
+		  value: true
+		});
+		Object.defineProperty(exports, "isIdentifierChar", {
+		  enumerable: true,
+		  get: function () {
+		    return _identifier.isIdentifierChar;
+		  }
+		});
+		Object.defineProperty(exports, "isIdentifierName", {
+		  enumerable: true,
+		  get: function () {
+		    return _identifier.isIdentifierName;
+		  }
+		});
+		Object.defineProperty(exports, "isIdentifierStart", {
+		  enumerable: true,
+		  get: function () {
+		    return _identifier.isIdentifierStart;
+		  }
+		});
+		Object.defineProperty(exports, "isKeyword", {
+		  enumerable: true,
+		  get: function () {
+		    return _keyword.isKeyword;
+		  }
+		});
+		Object.defineProperty(exports, "isReservedWord", {
+		  enumerable: true,
+		  get: function () {
+		    return _keyword.isReservedWord;
+		  }
+		});
+		Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+		  enumerable: true,
+		  get: function () {
+		    return _keyword.isStrictBindOnlyReservedWord;
+		  }
+		});
+		Object.defineProperty(exports, "isStrictBindReservedWord", {
+		  enumerable: true,
+		  get: function () {
+		    return _keyword.isStrictBindReservedWord;
+		  }
+		});
+		Object.defineProperty(exports, "isStrictReservedWord", {
+		  enumerable: true,
+		  get: function () {
+		    return _keyword.isStrictReservedWord;
+		  }
+		});
+		var _identifier = requireIdentifier();
+		var _keyword = requireKeyword(); 
+	} (lib));
+	return lib;
+}
+
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib$1;
+	hasRequiredLib = 1;
+
+	Object.defineProperty(lib$1, '__esModule', {
+	  value: true
+	});
+	var picocolors = /*@__PURE__*/ requirePicocolors();
+	var jsTokens = requireJsTokens();
+	var helperValidatorIdentifier = requireLib$1();
+	function isColorSupported() {
+	  return typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported;
+	}
+	const compose = (f, g) => v => f(g(v));
+	function buildDefs(colors) {
+	  return {
+	    keyword: colors.cyan,
+	    capitalized: colors.yellow,
+	    jsxIdentifier: colors.yellow,
+	    punctuator: colors.yellow,
+	    number: colors.magenta,
+	    string: colors.green,
+	    regex: colors.magenta,
+	    comment: colors.gray,
+	    invalid: compose(compose(colors.white, colors.bgRed), colors.bold),
+	    gutter: colors.gray,
+	    marker: compose(colors.red, colors.bold),
+	    message: compose(colors.red, colors.bold),
+	    reset: colors.reset
+	  };
+	}
+	const defsOn = buildDefs(picocolors.createColors(true));
+	const defsOff = buildDefs(picocolors.createColors(false));
+	function getDefs(enabled) {
+	  return enabled ? defsOn : defsOff;
+	}
+	const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
+	const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+	const BRACKET = /^[()[\]{}]$/;
+	let tokenize;
+	{
+	  const JSX_TAG = /^[a-z][\w-]*$/i;
+	  const getTokenType = function (token, offset, text) {
+	    if (token.type === "name") {
+	      if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
+	        return "keyword";
+	      }
+	      if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+	        return "jsxIdentifier";
+	      }
+	      if (token.value[0] !== token.value[0].toLowerCase()) {
+	        return "capitalized";
+	      }
+	    }
+	    if (token.type === "punctuator" && BRACKET.test(token.value)) {
+	      return "bracket";
+	    }
+	    if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+	      return "punctuator";
+	    }
+	    return token.type;
+	  };
+	  tokenize = function* (text) {
+	    let match;
+	    while (match = jsTokens.default.exec(text)) {
+	      const token = jsTokens.matchToToken(match);
+	      yield {
+	        type: getTokenType(token, match.index, text),
+	        value: token.value
+	      };
+	    }
+	  };
+	}
+	function highlight(text) {
+	  if (text === "") return "";
+	  const defs = getDefs(true);
+	  let highlighted = "";
+	  for (const {
+	    type,
+	    value
+	  } of tokenize(text)) {
+	    if (type in defs) {
+	      highlighted += value.split(NEWLINE$1).map(str => defs[type](str)).join("\n");
+	    } else {
+	      highlighted += value;
+	    }
+	  }
+	  return highlighted;
+	}
+	let deprecationWarningShown = false;
+	const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+	function getMarkerLines(loc, source, opts) {
+	  const startLoc = Object.assign({
+	    column: 0,
+	    line: -1
+	  }, loc.start);
+	  const endLoc = Object.assign({}, startLoc, loc.end);
+	  const {
+	    linesAbove = 2,
+	    linesBelow = 3
+	  } = opts || {};
+	  const startLine = startLoc.line;
+	  const startColumn = startLoc.column;
+	  const endLine = endLoc.line;
+	  const endColumn = endLoc.column;
+	  let start = Math.max(startLine - (linesAbove + 1), 0);
+	  let end = Math.min(source.length, endLine + linesBelow);
+	  if (startLine === -1) {
+	    start = 0;
+	  }
+	  if (endLine === -1) {
+	    end = source.length;
+	  }
+	  const lineDiff = endLine - startLine;
+	  const markerLines = {};
+	  if (lineDiff) {
+	    for (let i = 0; i <= lineDiff; i++) {
+	      const lineNumber = i + startLine;
+	      if (!startColumn) {
+	        markerLines[lineNumber] = true;
+	      } else if (i === 0) {
+	        const sourceLength = source[lineNumber - 1].length;
+	        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+	      } else if (i === lineDiff) {
+	        markerLines[lineNumber] = [0, endColumn];
+	      } else {
+	        const sourceLength = source[lineNumber - i].length;
+	        markerLines[lineNumber] = [0, sourceLength];
+	      }
+	    }
+	  } else {
+	    if (startColumn === endColumn) {
+	      if (startColumn) {
+	        markerLines[startLine] = [startColumn, 0];
+	      } else {
+	        markerLines[startLine] = true;
+	      }
+	    } else {
+	      markerLines[startLine] = [startColumn, endColumn - startColumn];
+	    }
+	  }
+	  return {
+	    start,
+	    end,
+	    markerLines
+	  };
+	}
+	function codeFrameColumns(rawLines, loc, opts = {}) {
+	  const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+	  const defs = getDefs(shouldHighlight);
+	  const lines = rawLines.split(NEWLINE);
+	  const {
+	    start,
+	    end,
+	    markerLines
+	  } = getMarkerLines(loc, lines, opts);
+	  const hasColumns = loc.start && typeof loc.start.column === "number";
+	  const numberMaxWidth = String(end).length;
+	  const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
+	  let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+	    const number = start + 1 + index;
+	    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+	    const gutter = ` ${paddedNumber} |`;
+	    const hasMarker = markerLines[number];
+	    const lastMarkerLine = !markerLines[number + 1];
+	    if (hasMarker) {
+	      let markerLine = "";
+	      if (Array.isArray(hasMarker)) {
+	        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+	        const numberOfMarkers = hasMarker[1] || 1;
+	        markerLine = ["\n ", defs.gutter(gutter.replace(/\d/g, " ")), " ", markerSpacing, defs.marker("^").repeat(numberOfMarkers)].join("");
+	        if (lastMarkerLine && opts.message) {
+	          markerLine += " " + defs.message(opts.message);
+	        }
+	      }
+	      return [defs.marker(">"), defs.gutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+	    } else {
+	      return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+	    }
+	  }).join("\n");
+	  if (opts.message && !hasColumns) {
+	    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+	  }
+	  if (shouldHighlight) {
+	    return defs.reset(frame);
+	  } else {
+	    return frame;
+	  }
+	}
+	function index(rawLines, lineNumber, colNumber, opts = {}) {
+	  if (!deprecationWarningShown) {
+	    deprecationWarningShown = true;
+	    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+	    if (process.emitWarning) {
+	      process.emitWarning(message, "DeprecationWarning");
+	    } else {
+	      const deprecationError = new Error(message);
+	      deprecationError.name = "DeprecationWarning";
+	      console.warn(new Error(message));
+	    }
+	  }
+	  colNumber = Math.max(colNumber, 0);
+	  const location = {
+	    start: {
+	      column: colNumber,
+	      line: lineNumber
+	    }
+	  };
+	  return codeFrameColumns(rawLines, location, opts);
+	}
+	lib$1.codeFrameColumns = codeFrameColumns;
+	lib$1.default = index;
+	lib$1.highlight = highlight;
+	return lib$1;
+}
+
+var libExports = requireLib();
+
+const NewLine = '\n';
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const RE_OBJECT_AS = /^\s*at (async )?Object\.\w+ \[as ([\w\.]+)\]/;
+const RE_GET_RESPONSE = /^\s*at async getResponse/;
+const RE_WEBSOCKET_HANDLE_MESSAGE = /^\s*at async WebSocket.handleMessage/;
+const RE_EXECUTE_COMMAND_ASYNC = /^\s*at executeCommandAsync/;
+const RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT = /^\s*at async MessagePort\.handleOtherMessagesFromMessagePort/;
+const RE_ASSERT = /^\s*at .*\/Assert\.js/;
+const isInternalLine = line => {
+  return line.includes('node:') || RE_AT_PROMISE_INDEX.test(line) || line.includes('node_modules/ws');
+};
+const isRelevantLine = line => {
+  return !isInternalLine(line);
+};
+const isApplicationUsefulLine = (line, index) => {
+  if (index === 0) {
+    if (RE_ASSERT.test(line)) {
+      return false;
+    }
+    return true;
+  }
+  if (RE_GET_RESPONSE.test(line)) {
+    return false;
+  }
+  if (RE_WEBSOCKET_HANDLE_MESSAGE.test(line)) {
+    return false;
+  }
+  if (RE_EXECUTE_COMMAND_ASYNC.test(line)) {
+    return false;
+  }
+  if (RE_HANDLE_OTHER_MESSAGES_FROM_MESSAGE_PORT.test(line)) {
+    return false;
+  }
+  return true;
+};
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const cleanLine = line => {
+  if (line.startsWith('    at exports.')) {
+    return '    at ' + line.slice('    at exports.'.length);
+  }
+  if (line.startsWith('    at async exports.')) {
+    return '    at async ' + line.slice('    at async exports.'.length);
+  }
+  if (line.startsWith('    at async Module.')) {
+    return '    at async ' + line.slice('    at async Module.'.length);
+  }
+  if (line.startsWith('    at Module.')) {
+    return '    at ' + line.slice('    at Module.'.length);
+  }
+  const objectMatch = line.match(RE_OBJECT_AS);
+  if (objectMatch) {
+    const rest = line.slice(objectMatch[0].length);
+    if (objectMatch[1]) {
+      return '    at ' + objectMatch[1] + objectMatch[2] + rest;
+    }
+    return '    at ' + objectMatch[2] + rest;
+  }
+  return line;
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  return {
+    custom: lines.slice(0, index),
+    actualStack: lines.slice(index).map(cleanLine)
+  };
+};
+const RE_PATH_1 = /^\/(.*)(\d+)$/;
+const mergeCustom = (custom, relevantStack) => {
+  if (custom.length === 0) {
+    return relevantStack;
+  }
+  const firstLine = custom[0];
+  if (RE_PATH_1.test(firstLine)) {
+    return [`    at ${firstLine}`, ...relevantStack];
+  }
+  return relevantStack;
+};
+const cleanStack = stack => {
+  const lines = splitLines(stack);
+  const {
+    custom,
+    actualStack
+  } = getDetails(lines);
+  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine);
+  const merged = mergeCustom(custom, relevantStack);
+  return merged;
+};
+const Utf8 = 'utf8';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const getActualPath = fileUri => {
+  if (fileUri.startsWith('file://')) {
+    return fileURLToPath(fileUri);
+  }
+  return fileUri;
+};
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const RE_MODULE_NOT_FOUND_STACK = /Cannot find package '([^']+)' imported from (.+)$/;
+const prepareModuleNotFoundError = error => {
+  const {
+    message
+  } = error;
+  const match = message.match(RE_MODULE_NOT_FOUND_STACK);
+  if (!match) {
+    return {
+      message,
+      stack: error.stack,
+      codeFrame: ''
+    };
+  }
+  const notFoundModule = match[1];
+  const importedFrom = match[2];
+  const rawLines = readFileSync(importedFrom, Utf8);
+  let line = 0;
+  let column = 0;
+  const splittedLines = splitLines(rawLines);
+  for (let i = 0; i < splittedLines.length; i++) {
+    const splittedLine = splittedLines[i];
+    const index = splittedLine.indexOf(notFoundModule);
+    if (index !== -1) {
+      line = i + 1;
+      column = index;
+      break;
+    }
+  }
+  const location = {
+    start: {
+      line,
+      column
+    }
+  };
+  const codeFrame = libExports.codeFrameColumns(rawLines, location);
+  const stackLines = splitLines(error.stack);
+  const newStackLines = [stackLines[0], `    at ${importedFrom}:${line}:${column}`, ...stackLines.slice(1)];
+  const newStack = joinLines(newStackLines);
+  return {
+    message,
+    stack: newStack,
+    codeFrame
+  };
+};
+const prepare = error => {
+  try {
+    if (error && error.code === ERR_MODULE_NOT_FOUND) {
+      return prepareModuleNotFoundError(error);
+    }
+    const {
+      message
+    } = error;
+    if (error && error.cause && typeof error.cause === 'function') {
+      const cause = error.cause();
+      if (cause) {
+        error = cause;
+      }
+    }
+    const lines = cleanStack(error.stack);
+    const file = lines[0];
+    let codeFrame = '';
+    if (error.codeFrame) {
+      codeFrame = error.codeFrame;
+    } else if (file) {
+      let match = file.match(/\((.*):(\d+):(\d+)\)$/);
+      if (!match) {
+        match = file.match(/at (.*):(\d+):(\d+)$/);
+      }
+      if (match) {
+        const [_, path, line, column] = match;
+        const actualPath = getActualPath(path);
+        const rawLines = readFileSync(actualPath, Utf8);
+        const location = {
+          start: {
+            line: Number.parseInt(line),
+            column: Number.parseInt(column)
+          }
+        };
+        codeFrame = libExports.codeFrameColumns(rawLines, location);
+      }
+    }
+    const relevantStack = joinLines(lines);
+    return {
+      message,
+      stack: relevantStack,
+      codeFrame,
+      type: error.constructor.name,
+      code: error.code
+    };
+  } catch (otherError) {
+    warn(`ErrorHandling Error: ${otherError}`);
+    return error;
+  }
+};
+
 const firstErrorLine = error => {
   if (error.stack) {
     return error.stack.slice(0, getNewLineIndex(error.stack));
@@ -507,7 +2272,7 @@ const handleUncaughtExceptionMonitor$1 = error$1 => {
   const prettyError = prepare(error$1);
   error(
   // @ts-ignore
-  prettyError.codeFrame + NewLine + prettyError.stack + NewLine);
+  prettyError.codeFrame + NewLine$1 + prettyError.stack + NewLine$1);
   setExitCode(Error$1);
 };
 
@@ -528,3 +2293,36 @@ const main = async () => {
 };
 
 main();
+
+const createWebSocketServer = async () => {
+  const _ws = await import('ws');
+  // workaround for jest or node bug
+  const WebSocketServer = _ws.WebSocketServer ? _ws.WebSocketServer :
+  // @ts-ignore
+  _ws.default.WebSocketServer;
+  const webSocketServer = new WebSocketServer({
+    noServer: true
+
+    // TODO not sure if ws compress is working at all
+    // perMessageDeflate: true
+  });
+  return webSocketServer;
+};
+const doSocketUpgrade = (webSocketServer, request, socket) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  webSocketServer.handleUpgrade(request, socket, Buffer.alloc(0), resolve);
+  return promise;
+};
+const handleUpgrade = async (request, socket) => {
+  const webSocketServer = await createWebSocketServer();
+  const webSocket = await doSocketUpgrade(webSocketServer, request, socket);
+  return webSocket;
+};
+
+const index = {
+  __proto__: null,
+  handleUpgrade
+};