@lvce-editor/static-server 0.56.10 → 0.56.12

package/static/0fd710b/packages/error-worker/dist/errorWorkerMain.js

@@ -1,2344 +0,0 @@
-class HTTPError extends Error {
-  response;
-  request;
-  options;
-  constructor(response, request, options) {
-    const code = response.status || response.status === 0 ? response.status : '';
-    const title = response.statusText || '';
-    const status = `${code} ${title}`.trim();
-    const reason = status ? `status code ${status}` : 'an unknown error';
-    super(`Request failed with ${reason}: ${request.method} ${request.url}`);
-    this.name = 'HTTPError';
-    this.response = response;
-    this.request = request;
-    this.options = options;
-  }
-}
-
-class TimeoutError extends Error {
-  request;
-  constructor(request) {
-    super(`Request timed out: ${request.method} ${request.url}`);
-    this.name = 'TimeoutError';
-    this.request = request;
-  }
-}
-
-const supportsRequestStreams = (() => {
-  let duplexAccessed = false;
-  let hasContentType = false;
-  const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
-  const supportsRequest = typeof globalThis.Request === 'function';
-  if (supportsReadableStream && supportsRequest) {
-    try {
-      hasContentType = new globalThis.Request('https://empty.invalid', {
-        body: new globalThis.ReadableStream(),
-        method: 'POST',
-        // @ts-expect-error - Types are outdated.
-        get duplex() {
-          duplexAccessed = true;
-          return 'half';
-        }
-      }).headers.has('Content-Type');
-    } catch (error) {
-      // QQBrowser on iOS throws "unsupported BodyInit type" error (see issue #581)
-      if (error instanceof Error && error.message === 'unsupported BodyInit type') {
-        return false;
-      }
-      throw error;
-    }
-  }
-  return duplexAccessed && !hasContentType;
-})();
-const supportsAbortController = typeof globalThis.AbortController === 'function';
-const supportsResponseStreams = typeof globalThis.ReadableStream === 'function';
-const supportsFormData = typeof globalThis.FormData === 'function';
-const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
-const responseTypes = {
-  json: 'application/json',
-  text: 'text/*',
-  formData: 'multipart/form-data',
-  arrayBuffer: '*/*',
-  blob: '*/*'
-};
-// The maximum value of a 32bit int (see issue #117)
-const maxSafeTimeout = 2_147_483_647;
-// Size in bytes of a typical form boundary, used to help estimate upload size
-const usualFormBoundarySize = new TextEncoder().encode('------WebKitFormBoundaryaxpyiPgbbPti10Rw').length;
-const stop = Symbol('stop');
-const kyOptionKeys = {
-  json: true,
-  parseJson: true,
-  stringifyJson: true,
-  searchParams: true,
-  prefixUrl: true,
-  retry: true,
-  timeout: true,
-  hooks: true,
-  throwHttpErrors: true,
-  onDownloadProgress: true,
-  onUploadProgress: true,
-  fetch: true
-};
-const requestOptionsRegistry = {
-  method: true,
-  headers: true,
-  body: true,
-  mode: true,
-  credentials: true,
-  cache: true,
-  redirect: true,
-  referrer: true,
-  referrerPolicy: true,
-  integrity: true,
-  keepalive: true,
-  signal: true,
-  window: true,
-  dispatcher: true,
-  duplex: true,
-  priority: true
-};
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-const getBodySize = body => {
-  if (!body) {
-    return 0;
-  }
-  if (body instanceof FormData) {
-    // This is an approximation, as FormData size calculation is not straightforward
-    let size = 0;
-    for (const [key, value] of body) {
-      size += usualFormBoundarySize;
-      size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
-      size += typeof value === 'string' ? new TextEncoder().encode(value).length : value.size;
-    }
-    return size;
-  }
-  if (body instanceof Blob) {
-    return body.size;
-  }
-  if (body instanceof ArrayBuffer) {
-    return body.byteLength;
-  }
-  if (typeof body === 'string') {
-    return new TextEncoder().encode(body).length;
-  }
-  if (body instanceof URLSearchParams) {
-    return new TextEncoder().encode(body.toString()).length;
-  }
-  if ('byteLength' in body) {
-    return body.byteLength;
-  }
-  if (typeof body === 'object' && body !== null) {
-    try {
-      const jsonString = JSON.stringify(body);
-      return new TextEncoder().encode(jsonString).length;
-    } catch {
-      return 0;
-    }
-  }
-  return 0; // Default case, unable to determine size
-};
-const streamResponse = (response, onDownloadProgress) => {
-  const totalBytes = Number(response.headers.get('content-length')) || 0;
-  let transferredBytes = 0;
-  if (response.status === 204) {
-    if (onDownloadProgress) {
-      onDownloadProgress({
-        percent: 1,
-        totalBytes,
-        transferredBytes
-      }, new Uint8Array());
-    }
-    return new Response(null, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-  return new Response(new ReadableStream({
-    async start(controller) {
-      const reader = response.body.getReader();
-      if (onDownloadProgress) {
-        onDownloadProgress({
-          percent: 0,
-          transferredBytes: 0,
-          totalBytes
-        }, new Uint8Array());
-      }
-      async function read() {
-        const {
-          done,
-          value
-        } = await reader.read();
-        if (done) {
-          controller.close();
-          return;
-        }
-        if (onDownloadProgress) {
-          transferredBytes += value.byteLength;
-          const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          onDownloadProgress({
-            percent,
-            transferredBytes,
-            totalBytes
-          }, value);
-        }
-        controller.enqueue(value);
-        await read();
-      }
-      await read();
-    }
-  }), {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-};
-const streamRequest = (request, onUploadProgress) => {
-  const totalBytes = getBodySize(request.body);
-  let transferredBytes = 0;
-  return new Request(request, {
-    // @ts-expect-error - Types are outdated.
-    duplex: 'half',
-    body: new ReadableStream({
-      async start(controller) {
-        const reader = request.body instanceof ReadableStream ? request.body.getReader() : new Response('').body.getReader();
-        async function read() {
-          const {
-            done,
-            value
-          } = await reader.read();
-          if (done) {
-            // Ensure 100% progress is reported when the upload is complete
-            if (onUploadProgress) {
-              onUploadProgress({
-                percent: 1,
-                transferredBytes,
-                totalBytes: Math.max(totalBytes, transferredBytes)
-              }, new Uint8Array());
-            }
-            controller.close();
-            return;
-          }
-          transferredBytes += value.byteLength;
-          let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          if (totalBytes < transferredBytes || percent === 1) {
-            percent = 0.99;
-          }
-          if (onUploadProgress) {
-            onUploadProgress({
-              percent: Number(percent.toFixed(2)),
-              transferredBytes,
-              totalBytes
-            }, value);
-          }
-          controller.enqueue(value);
-          await read();
-        }
-        await read();
-      }
-    })
-  });
-};
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-const isObject = value => value !== null && typeof value === 'object';
-
-const validateAndMerge = (...sources) => {
-  for (const source of sources) {
-    if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {
-      throw new TypeError('The `options` argument must be an object');
-    }
-  }
-  return deepMerge({}, ...sources);
-};
-const mergeHeaders = (source1 = {}, source2 = {}) => {
-  const result = new globalThis.Headers(source1);
-  const isHeadersInstance = source2 instanceof globalThis.Headers;
-  const source = new globalThis.Headers(source2);
-  for (const [key, value] of source.entries()) {
-    if (isHeadersInstance && value === 'undefined' || value === undefined) {
-      result.delete(key);
-    } else {
-      result.set(key, value);
-    }
-  }
-  return result;
-};
-function newHookValue(original, incoming, property) {
-  return Object.hasOwn(incoming, property) && incoming[property] === undefined ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
-}
-const mergeHooks = (original = {}, incoming = {}) => ({
-  beforeRequest: newHookValue(original, incoming, 'beforeRequest'),
-  beforeRetry: newHookValue(original, incoming, 'beforeRetry'),
-  afterResponse: newHookValue(original, incoming, 'afterResponse'),
-  beforeError: newHookValue(original, incoming, 'beforeError')
-});
-// TODO: Make this strongly-typed (no `any`).
-const deepMerge = (...sources) => {
-  let returnValue = {};
-  let headers = {};
-  let hooks = {};
-  for (const source of sources) {
-    if (Array.isArray(source)) {
-      if (!Array.isArray(returnValue)) {
-        returnValue = [];
-      }
-      returnValue = [...returnValue, ...source];
-    } else if (isObject(source)) {
-      for (let [key, value] of Object.entries(source)) {
-        if (isObject(value) && key in returnValue) {
-          value = deepMerge(returnValue[key], value);
-        }
-        returnValue = {
-          ...returnValue,
-          [key]: value
-        };
-      }
-      if (isObject(source.hooks)) {
-        hooks = mergeHooks(hooks, source.hooks);
-        returnValue.hooks = hooks;
-      }
-      if (isObject(source.headers)) {
-        headers = mergeHeaders(headers, source.headers);
-        returnValue.headers = headers;
-      }
-    }
-  }
-  return returnValue;
-};
-
-const normalizeRequestMethod = input => requestMethods.includes(input) ? input.toUpperCase() : input;
-const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace'];
-const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
-const retryAfterStatusCodes = [413, 429, 503];
-const defaultRetryOptions = {
-  limit: 2,
-  methods: retryMethods,
-  statusCodes: retryStatusCodes,
-  afterStatusCodes: retryAfterStatusCodes,
-  maxRetryAfter: Number.POSITIVE_INFINITY,
-  backoffLimit: Number.POSITIVE_INFINITY,
-  delay: attemptCount => 0.3 * 2 ** (attemptCount - 1) * 1000
-};
-const normalizeRetryOptions = (retry = {}) => {
-  if (typeof retry === 'number') {
-    return {
-      ...defaultRetryOptions,
-      limit: retry
-    };
-  }
-  if (retry.methods && !Array.isArray(retry.methods)) {
-    throw new Error('retry.methods must be an array');
-  }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
-    throw new Error('retry.statusCodes must be an array');
-  }
-  return {
-    ...defaultRetryOptions,
-    ...retry
-  };
-};
-
-// `Promise.race()` workaround (#91)
-async function timeout(request, init, abortController, options) {
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      if (abortController) {
-        abortController.abort();
-      }
-      reject(new TimeoutError(request));
-    }, options.timeout);
-    void options.fetch(request, init).then(resolve).catch(reject).then(() => {
-      clearTimeout(timeoutId);
-    });
-  });
-}
-
-// https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111
-async function delay(ms, {
-  signal
-}) {
-  return new Promise((resolve, reject) => {
-    if (signal) {
-      signal.throwIfAborted();
-      signal.addEventListener('abort', abortHandler, {
-        once: true
-      });
-    }
-    function abortHandler() {
-      clearTimeout(timeoutId);
-      reject(signal.reason);
-    }
-    const timeoutId = setTimeout(() => {
-      signal?.removeEventListener('abort', abortHandler);
-      resolve();
-    }, ms);
-  });
-}
-
-const findUnknownOptions = (request, options) => {
-  const unknownOptions = {};
-  for (const key in options) {
-    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
-      unknownOptions[key] = options[key];
-    }
-  }
-  return unknownOptions;
-};
-
-class Ky {
-  static create(input, options) {
-    const ky = new Ky(input, options);
-    const function_ = async () => {
-      if (typeof ky._options.timeout === 'number' && ky._options.timeout > maxSafeTimeout) {
-        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-      }
-      // Delay the fetch so that body method shortcuts can set the Accept header
-      await Promise.resolve();
-      // Before using ky.request, _fetch clones it and saves the clone for future retries to use.
-      // If retry is not needed, close the cloned request's ReadableStream for memory safety.
-      let response = await ky._fetch();
-      for (const hook of ky._options.hooks.afterResponse) {
-        // eslint-disable-next-line no-await-in-loop
-        const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
-        if (modifiedResponse instanceof globalThis.Response) {
-          response = modifiedResponse;
-        }
-      }
-      ky._decorateResponse(response);
-      if (!response.ok && ky._options.throwHttpErrors) {
-        let error = new HTTPError(response, ky.request, ky._options);
-        for (const hook of ky._options.hooks.beforeError) {
-          // eslint-disable-next-line no-await-in-loop
-          error = await hook(error);
-        }
-        throw error;
-      }
-      // If `onDownloadProgress` is passed, it uses the stream API internally
-      if (ky._options.onDownloadProgress) {
-        if (typeof ky._options.onDownloadProgress !== 'function') {
-          throw new TypeError('The `onDownloadProgress` option must be a function');
-        }
-        if (!supportsResponseStreams) {
-          throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
-        }
-        return streamResponse(response.clone(), ky._options.onDownloadProgress);
-      }
-      return response;
-    };
-    const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
-    const result = (isRetriableMethod ? ky._retry(function_) : function_()).finally(async () => {
-      // Now that we know a retry is not needed, close the ReadableStream of the cloned request.
-      if (!ky.request.bodyUsed) {
-        await ky.request.body?.cancel();
-      }
-    });
-    for (const [type, mimeType] of Object.entries(responseTypes)) {
-      result[type] = async () => {
-        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-        ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
-        const response = await result;
-        if (type === 'json') {
-          if (response.status === 204) {
-            return '';
-          }
-          const arrayBuffer = await response.clone().arrayBuffer();
-          const responseSize = arrayBuffer.byteLength;
-          if (responseSize === 0) {
-            return '';
-          }
-          if (options.parseJson) {
-            return options.parseJson(await response.text());
-          }
-        }
-        return response[type]();
-      };
-    }
-    return result;
-  }
-  request;
-  abortController;
-  _retryCount = 0;
-  _input;
-  _options;
-  // eslint-disable-next-line complexity
-  constructor(input, options = {}) {
-    this._input = input;
-    this._options = {
-      ...options,
-      headers: mergeHeaders(this._input.headers, options.headers),
-      hooks: mergeHooks({
-        beforeRequest: [],
-        beforeRetry: [],
-        beforeError: [],
-        afterResponse: []
-      }, options.hooks),
-      method: normalizeRequestMethod(options.method ?? this._input.method ?? 'GET'),
-      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      prefixUrl: String(options.prefixUrl || ''),
-      retry: normalizeRetryOptions(options.retry),
-      throwHttpErrors: options.throwHttpErrors !== false,
-      timeout: options.timeout ?? 10_000,
-      fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
-    };
-    if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
-      throw new TypeError('`input` must be a string, URL, or Request');
-    }
-    if (this._options.prefixUrl && typeof this._input === 'string') {
-      if (this._input.startsWith('/')) {
-        throw new Error('`input` must not begin with a slash when using `prefixUrl`');
-      }
-      if (!this._options.prefixUrl.endsWith('/')) {
-        this._options.prefixUrl += '/';
-      }
-      this._input = this._options.prefixUrl + this._input;
-    }
-    if (supportsAbortController) {
-      const originalSignal = this._options.signal ?? this._input.signal;
-      this.abortController = new globalThis.AbortController();
-      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
-    }
-    if (supportsRequestStreams) {
-      // @ts-expect-error - Types are outdated.
-      this._options.duplex = 'half';
-    }
-    if (this._options.json !== undefined) {
-      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
-      this._options.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
-    }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (this._options.searchParams) {
-      // eslint-disable-next-line unicorn/prevent-abbreviations
-      const textSearchParams = typeof this._options.searchParams === 'string' ? this._options.searchParams.replace(/^\?/, '') : new URLSearchParams(this._options.searchParams).toString();
-      // eslint-disable-next-line unicorn/prevent-abbreviations
-      const searchParams = '?' + textSearchParams;
-      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      // To provide correct form boundary, Content-Type header should be deleted each time when new Request instantiated from another one
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
-        this.request.headers.delete('content-type');
-      }
-      // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
-      this.request = new globalThis.Request(new globalThis.Request(url, {
-        ...this.request
-      }), this._options);
-    }
-    // If `onUploadProgress` is passed, it uses the stream API internally
-    if (this._options.onUploadProgress) {
-      if (typeof this._options.onUploadProgress !== 'function') {
-        throw new TypeError('The `onUploadProgress` option must be a function');
-      }
-      if (!supportsRequestStreams) {
-        throw new Error('Request streams are not supported in your environment. The `duplex` option for `Request` is not available.');
-      }
-      const originalBody = this.request.body;
-      if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress);
-      }
-    }
-  }
-  _calculateRetryDelay(error) {
-    this._retryCount++;
-    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
-      throw error;
-    }
-    if (error instanceof HTTPError) {
-      if (!this._options.retry.statusCodes.includes(error.response.status)) {
-        throw error;
-      }
-      const retryAfter = error.response.headers.get('Retry-After') ?? error.response.headers.get('RateLimit-Reset') ?? error.response.headers.get('X-RateLimit-Reset') // GitHub
-      ?? error.response.headers.get('X-Rate-Limit-Reset'); // Twitter
-      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
-        let after = Number(retryAfter) * 1000;
-        if (Number.isNaN(after)) {
-          after = Date.parse(retryAfter) - Date.now();
-        } else if (after >= Date.parse('2024-01-01')) {
-          // A large number is treated as a timestamp (fixed threshold protects against clock skew)
-          after -= Date.now();
-        }
-        const max = this._options.retry.maxRetryAfter ?? after;
-        return after < max ? after : max;
-      }
-      if (error.response.status === 413) {
-        throw error;
-      }
-    }
-    const retryDelay = this._options.retry.delay(this._retryCount);
-    return Math.min(this._options.retry.backoffLimit, retryDelay);
-  }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = async () => this._options.parseJson(await response.text());
-    }
-    return response;
-  }
-  async _retry(function_) {
-    try {
-      return await function_();
-    } catch (error) {
-      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-      if (this._retryCount < 1) {
-        throw error;
-      }
-      await delay(ms, {
-        signal: this._options.signal
-      });
-      for (const hook of this._options.hooks.beforeRetry) {
-        // eslint-disable-next-line no-await-in-loop
-        const hookResult = await hook({
-          request: this.request,
-          options: this._options,
-          error: error,
-          retryCount: this._retryCount
-        });
-        // If `stop` is returned from the hook, the retry process is stopped
-        if (hookResult === stop) {
-          return;
-        }
-      }
-      return this._retry(function_);
-    }
-  }
-  async _fetch() {
-    for (const hook of this._options.hooks.beforeRequest) {
-      // eslint-disable-next-line no-await-in-loop
-      const result = await hook(this.request, this._options);
-      if (result instanceof Request) {
-        this.request = result;
-        break;
-      }
-      if (result instanceof Response) {
-        return result;
-      }
-    }
-    const nonRequestOptions = findUnknownOptions(this.request, this._options);
-    // Cloning is done here to prepare in advance for retries
-    const mainRequest = this.request;
-    this.request = mainRequest.clone();
-    if (this._options.timeout === false) {
-      return this._options.fetch(mainRequest, nonRequestOptions);
-    }
-    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
-  }
-}
-
-/*! MIT License © Sindre Sorhus */
-const createInstance = defaults => {
-  // eslint-disable-next-line @typescript-eslint/promise-function-async
-  const ky = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
-  for (const method of requestMethods) {
-    // eslint-disable-next-line @typescript-eslint/promise-function-async
-    ky[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, {
-      method
-    }));
-  }
-  ky.create = newDefaults => createInstance(validateAndMerge(newDefaults));
-  ky.extend = newDefaults => {
-    if (typeof newDefaults === 'function') {
-      newDefaults = newDefaults(defaults ?? {});
-    }
-    return createInstance(validateAndMerge(defaults, newDefaults));
-  };
-  ky.stop = stop;
-  return ky;
-};
-const ky = createInstance();
-
-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$3 = '\n';
-const getNewLineIndex$2 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, 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;
-    }
-  }
-}
-
-const getJson = async (url, options = {}) => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const result = await response.json();
-    return result;
-  } catch (error) {
-    if (error && error instanceof TypeError && error.message === 'Failed to fetch') {
-      throw new VError(`Failed to request json from "${url}". Make sure that the server is running and has CORS enabled`);
-    }
-    // @ts-ignore
-    error.message = `Failed to request json from "${url}": ${error.message}`;
-    throw error;
-  }
-};
-const getText = async (url, options = {}) => {
-  try {
-    if (url.startsWith('node:')) {
-      return '';
-    }
-    return await ky(url, options).text();
-  } catch (error) {
-    if (error && error instanceof TypeError && error.message === 'Failed to fetch') {
-      throw new VError(error, `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`);
-    }
-    throw new VError(error, `Failed to request text from "${url}"`);
-  }
-};
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType$1 = 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$1(value);
-  if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType$1(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const array = value => {
-  const type = getType$1(value);
-  if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array');
-  }
-};
-const string = value => {
-  const type = getType$1(value);
-  if (type !== 'string') {
-    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 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 = 'ERR_MODULE_NOT_FOUND';
-const NewLine$2 = '\n';
-const joinLines$2 = lines => {
-  return lines.join(NewLine$2);
-};
-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$2);
-};
-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
-  };
-};
-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 readyMessage = 'ready';
-const getData$2 = event => {
-  return event.data;
-};
-const listen$7 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$8 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-}
-const wrap$f = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
-};
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$8(parentIpcRaw);
-  const parentIpc = wrap$f(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
-  }
-  return globalThis;
-};
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$e = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
-};
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$e
-};
-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;
-};
-const Message$1 = 3;
-const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
-}) => {
-  if (!isMessagePort(messagePort)) {
-    throw new IpcError('port must be of type MessagePort');
-  }
-  if (isMessagePortOpen) {
-    return messagePort;
-  }
-  const eventPromise = getFirstEvent(messagePort, {
-    message: Message$1
-  });
-  messagePort.start();
-  const {
-    type,
-    event
-  } = await eventPromise;
-  if (type !== Message$1) {
-    throw new IpcError('Failed to wait for ipc message');
-  }
-  if (event.data !== readyMessage) {
-    throw new IpcError('unexpected first message');
-  }
-  return messagePort;
-};
-const signal$1 = messagePort => {
-  messagePort.start();
-};
-class IpcParentWithMessagePort extends Ipc {
-  getData = getData$2;
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    this._rawIpc.close();
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-  onClose(callback) {}
-}
-const wrap$5 = messagePort => {
-  return new IpcParentWithMessagePort(messagePort);
-};
-const IpcParentWithMessagePort$1 = {
-  __proto__: null,
-  create: create$5$1,
-  signal: signal$1,
-  wrap: wrap$5
-};
-
-const Two = '2.0';
-const create$4$1 = (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 = id => {
-  delete callbacks[id];
-};
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$1(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (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$1 = '\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$1);
-};
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
-};
-const getCurrentStack = () => {
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(2));
-  return currentStack;
-};
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$1 + 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$1 + currentStack;
-    }
-    return error;
-  }
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$1 + 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$1 + error.data.stack + NewLine$1 + 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(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$1(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$1(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 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 Error(`command not found ${command}`);
-  }
-  return fn(...args);
-};
-
-const createRpc = ipc => {
-  const rpc = {
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
-    }
-  };
-  return rpc;
-};
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError = () => {
-  // handled by renderer worker
-};
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
-};
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
-};
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-const create$3 = async ({
-  commandMap,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
-};
-const create$2 = async ({
-  commandMap,
-  messagePort
-}) => {
-  return create$3({
-    commandMap,
-    messagePort
-  });
-};
-const PlainMessagePortRpcParent = {
-  __proto__: null,
-  create: create$2
-};
-const create$4 = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$4
-};
-
-const commandMapRef = Object.create(null);
-
-const handleMessagePort2 = async port => {
-  await PlainMessagePortRpcParent.create({
-    messagePort: port,
-    commandMap: commandMapRef
-  });
-};
-
-const EmptyString = '';
-const NewLine = '\n';
-
-const splitLines = lines => {
-  string(lines);
-  return lines.split(NewLine);
-};
-
-// @ts-nocheck
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const RE_OBJECT_AS = /^\s*at Object\.\w+ \[as ([\w\.]+)\]/;
-const RE_OBJECT = /^\s*at Object\.(\w+)/;
-const RE_ASYNC_OBJECT = /^\s*at async Object\.(\w+)/;
-const RE_PATH_1$2 = /\((.*):(\d+):(\d+)\)$/;
-const RE_PATH_2$2 = /at (.*):(\d+):(\d+)$/;
-const RE_PATH_3$2 = /@(.*):(\d+):(\d+)$/; // Firefox
-const RE_RESTORE_JSON_RPC_ERROR = /^\s*at restoreJsonRpcError/;
-const RE_UNWRAP_JSON_RPC_RESULT = /^\s*at unwrapJsonRpcResult/;
-const RE_GET_RESPONSE = /^\s*at getResponse/;
-const RE_JSON_RPC_INVOKE = /^\s*at invoke .*JsonRpc\.js/;
-const RE_ASSERT = /^\s*at .*\/Assert\.js/;
-const RE_CONSTRUCT_ERROR = /^\s*at constructError /;
-const isInternalLine = line => {
-  return RE_AT_PROMISE_INDEX.test(line);
-};
-const isRelevantLine = line => {
-  return !isInternalLine(line);
-};
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line) || RE_PATH_2$2.test(line) || RE_PATH_3$2.test(line);
-};
-const isApplicationUsefulLine = (line, index) => {
-  if (index === 0) {
-    if (RE_ASSERT.test(line)) {
-      return false;
-    }
-    return true;
-  }
-  if (RE_RESTORE_JSON_RPC_ERROR.test(line) || RE_JSON_RPC_INVOKE.test(line) || RE_UNWRAP_JSON_RPC_RESULT.test(line) || RE_CONSTRUCT_ERROR.test(line) || RE_GET_RESPONSE.test(line)) {
-    return false;
-  }
-  return true;
-};
-const cleanLine = line => {
-  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 objectAsMatch = line.match(RE_OBJECT_AS);
-  if (objectAsMatch) {
-    return '    at ' + objectAsMatch[1] + line.slice(objectAsMatch[0].length);
-  }
-  const objectMatch = line.match(RE_OBJECT);
-  if (objectMatch) {
-    return '    at ' + objectMatch[1] + line.slice(objectMatch[0].length);
-  }
-  const asyncObjectMatch = line.match(RE_ASYNC_OBJECT);
-  if (asyncObjectMatch) {
-    return '    at async ' + asyncObjectMatch[1] + line.slice(asyncObjectMatch[0].length);
-  }
-  return line;
-};
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  return {
-    custom: lines.slice(0, index),
-    actualStack: lines.slice(index).map(cleanLine)
-  };
-};
-const mergeCustom = (custom, relevantStack) => {
-  if (custom.length === 0) {
-    return relevantStack;
-  }
-  const firstLine = custom[0];
-  if (RE_PATH_1$2.test(firstLine)) {
-    return [`    at ${firstLine}`, ...relevantStack];
-  }
-  if (RE_PATH_2$2.test(firstLine)) {
-    return [`    at ${firstLine}`, ...relevantStack];
-  }
-  if (RE_PATH_3$2.test(firstLine)) {
-    return [firstLine, ...relevantStack];
-  }
-  return relevantStack;
-};
-const cleanStack = stack => {
-  string(stack);
-  const lines = splitLines(stack);
-  const {
-    custom,
-    actualStack
-  } = getDetails(lines);
-  const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine);
-  const merged = mergeCustom(custom, relevantStack);
-  return merged;
-};
-
-// @ts-nocheck
-// based on https://github.com/babel/babel/blob/6be6e04f396f03feace4431f709564a8d842163a/packages/babel-code-frame/src/index.ts (License MIT)
-
-/**
- * RegExp to test for newlines in terminal.
- */
-
-const NEWLINE = /\n/;
-
-/**
- * Extract what lines should be marked and highlighted.
- */
-const getMarkerLines = (loc, source, opts) => {
-  const startLoc = {
-    column: 0,
-    line: -1,
-    ...loc.start
-  };
-  const endLoc = {
-    ...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) {
-    markerLines[startLine] = startColumn ? [startColumn, 0] : true;
-  } else {
-    markerLines[startLine] = [startColumn, endColumn - startColumn];
-  }
-  return {
-    start,
-    end,
-    markerLines
-  };
-};
-const create$1 = (rawLines, loc, opts = {}) => {
-  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;
-  let frame = rawLines.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)).replaceAll(/[^\t]/g, ' ');
-        const numberOfMarkers = hasMarker[1] || 1;
-        markerLine = ['\n ', gutter.replaceAll(/\d/g, ' '), ' ', markerSpacing, '^'.repeat(numberOfMarkers)].join('');
-        if (lastMarkerLine && opts.message) {
-          markerLine += ' ' + opts.message;
-        }
-      }
-      return ['>', gutter, line.length > 0 ? ` ${line}` : '', markerLine].join('');
-    }
-    return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`;
-  }).join(NewLine);
-  if (opts.message && !hasColumns) {
-    frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
-  }
-  return frame;
-};
-
-const getErrorMessage = error => {
-  if (!error) {
-    return `Error: ${error}`;
-  }
-  let {
-    message
-  } = error;
-  while (error.cause) {
-    error = error.cause;
-    message += `: ${error}`;
-  }
-  return message;
-};
-
-const RE_PATH_1$1 = /\((.*):(\d+):(\d+)\)$/;
-const RE_PATH_2$1 = /at (.*):(\d+):(\d+)$/;
-const RE_PATH_3$1 = /@(.*):(\d+):(\d+)$/; // Firefox
-
-const getFile = lines => {
-  for (const line of lines) {
-    if (RE_PATH_1$1.test(line) || RE_PATH_2$1.test(line) || RE_PATH_3$1.test(line)) {
-      return line;
-    }
-  }
-  return '';
-};
-
-const getNewLineIndex = (string, startIndex) => {
-  return string.indexOf(NewLine, startIndex);
-};
-
-const RE_SOURCE_MAP = /^\/\/# sourceMappingURL=(.*)$/;
-const getSourceMapMatch = text => {
-  string(text);
-  const index = text.lastIndexOf(NewLine, text.length - 2);
-  const lastLine = text.slice(index + 1, -1);
-  const lastLineMatch = lastLine.match(RE_SOURCE_MAP);
-  if (lastLineMatch) {
-    return lastLineMatch;
-  }
-  const secondLastLineIndex = getNewLineIndex(text, index - 1);
-  const secondLastLine = text.slice(secondLastLineIndex, index);
-  const secondLastLineMatch = secondLastLine.match(RE_SOURCE_MAP);
-  return secondLastLineMatch;
-};
-
-const isActualSourceFile = path => {
-  if (path === '<anonymous>' || path === 'debugger eval code' || path.startsWith('"') || path.startsWith("'") || path.startsWith(')') || path.startsWith('file://')) {
-    return false;
-  }
-  return true;
-};
-
-const getIsFirefox = () => {
-  if (typeof navigator === 'undefined') {
-    return false;
-  }
-  if (
-  // @ts-ignore
-  navigator.userAgentData &&
-  // @ts-ignore
-  navigator.userAgentData.brands) {
-    // @ts-ignore
-    return navigator.userAgentData.brands.includes('Firefox');
-  }
-  return navigator.userAgent.toLowerCase().includes('firefox');
-};
-const isFirefox = getIsFirefox();
-
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
-
-const warn = (...args) => {
-  console.warn(...args);
-};
-const error = (...args) => {
-  console.error(...args);
-};
-
-const isEmptyString = string => {
-  return string === EmptyString;
-};
-
-// @ts-nocheck
-// copied from https://github.com/Rich-Harris/vlq/blob/e3009f5757abeb0b5b6233045f3bbdaf86435d08/src/index.js by Rich Harris (License MIT)
-
-/** @type {Record<string, number>} */
-const char_to_integer = {};
-for (const [i, char] of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='.split('').entries()) {
-  char_to_integer[char] = i;
-}
-
-/** @param {string} string */
-const decode = string => {
-  /** @type {number[]} */
-  const result = [];
-  let shift = 0;
-  let value = 0;
-  for (let i = 0; i < string.length; i += 1) {
-    let integer = char_to_integer[string[i]];
-    if (integer === undefined) {
-      throw new Error('Invalid character (' + string[i] + ')');
-    }
-    const has_continuation_bit = integer & 32;
-    integer &= 31;
-    value += integer << shift;
-    if (has_continuation_bit) {
-      shift += 5;
-    } else {
-      const should_negate = value & 1;
-      value >>>= 1;
-      if (should_negate) {
-        result.push(value === 0 ? -2147483648 : -value);
-      } else {
-        result.push(value);
-      }
-
-      // reset
-      value = shift = 0;
-    }
-  }
-  return result;
-};
-
-const getColumnMapping = (mappings, line, column) => {
-  string(mappings);
-  number(line);
-  number(column);
-  let currentColumn = 0;
-  let currentLine = 1;
-  let originalSourceFileIndex = 0;
-  let originalLine = 0;
-  let originalColumn = 0;
-  let index = 0;
-  while (index !== -1) {
-    currentColumn = 0;
-    const newLineIndex = mappings.indexOf(';', index + 1);
-    currentLine++;
-    if (currentLine === line) {
-      const lineMapping = mappings.slice(index + 1, newLineIndex) + ',';
-      index = -1;
-      while (true) {
-        const newIndex = lineMapping.indexOf(',', index + 1);
-        if (newIndex === -1) {
-          throw new Error('no mapping found');
-        }
-        const chunk = lineMapping.slice(index + 1, newIndex);
-        const decodedChunk = decode(chunk);
-        currentColumn += decodedChunk[0];
-        originalSourceFileIndex += decodedChunk[1];
-        originalLine += decodedChunk[2];
-        originalColumn += decodedChunk[3];
-        index = newIndex;
-        if (currentColumn >= column) {
-          return {
-            originalSourceFileIndex,
-            originalLine: originalLine + 1,
-            originalColumn
-          };
-        }
-      }
-    } else {
-      const lineMappings = mappings.slice(index + 1, newLineIndex);
-      if (isEmptyString(lineMappings)) {
-        index = newLineIndex;
-        continue;
-      }
-      const chunks = lineMappings.split(',');
-      for (const chunk of chunks) {
-        const decodedChunk = decode(chunk);
-        currentColumn += decodedChunk[0];
-        originalSourceFileIndex += decodedChunk[1];
-        originalLine += decodedChunk[2];
-        originalColumn += decodedChunk[3];
-      }
-    }
-    index = newLineIndex;
-  }
-  throw new Error('no mapping found');
-};
-const getOriginalPosition = (sourceMap, line, column) => {
-  try {
-    object(sourceMap);
-    string(sourceMap.mappings);
-    array(sourceMap.sources);
-    array(sourceMap.names);
-    number(line);
-    number(column);
-    const {
-      sources,
-      mappings
-    } = sourceMap;
-    if (!mappings) {
-      throw new Error(`no source for line ${line} found`);
-    }
-    const {
-      originalLine,
-      originalColumn,
-      originalSourceFileIndex
-    } = getColumnMapping(mappings, line, column);
-    const source = sources[originalSourceFileIndex];
-    return {
-      source,
-      originalLine,
-      originalColumn
-    };
-  } catch (error) {
-    throw new VError(error, 'Failed to get original sourcemap position');
-  }
-};
-
-const prepareErrorMessageWithCodeFrame = error => {
-  if (!error) {
-    return {
-      message: error,
-      stack: undefined,
-      codeFrame: undefined,
-      type: 'Error',
-      _error: error
-    };
-  }
-  const message = getErrorMessage(error);
-  const lines = cleanStack(error.stack);
-  const relevantStack = joinLines(lines);
-  if (error.codeFrame) {
-    return {
-      message,
-      stack: relevantStack,
-      codeFrame: error.codeFrame,
-      type: error.constructor.name,
-      _error: error
-    };
-  }
-  return {
-    message,
-    stack: error.originalStack,
-    codeFrame: error.originalCodeFrame,
-    category: error.category,
-    stderr: error.stderr,
-    _error: error
-  };
-};
-const RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/;
-const RE_PATH_2 = /at (.*):(\d+):(\d+)$/;
-const RE_PATH_3 = /@(.*):(\d+):(\d+)$/; // Firefox
-
-const getSourceMapAbsolutePath = (file, relativePath) => {
-  const folder = file.slice(0, file.lastIndexOf('/'));
-  const absolutePath = folder + '/' + relativePath;
-  return absolutePath;
-};
-const toAbsoluteUrl = (file, relativePath) => {
-  const url = new URL(relativePath, file);
-  return url.href;
-};
-const getType = error => {
-  const constructorName = error.constructor.name;
-  if (constructorName === 'Object') {
-    return 'Error';
-  }
-  return constructorName;
-};
-const prepareErrorMessageWithoutCodeFrame = async error => {
-  try {
-    const lines = cleanStack(error.stack);
-    const file = getFile(lines);
-    let match = file.match(RE_PATH_1);
-    match ||= file.match(RE_PATH_2);
-    match ||= file.match(RE_PATH_3);
-    if (!match) {
-      return error;
-    }
-    const [_, path, line, column] = match;
-    if (!isActualSourceFile(path)) {
-      return error;
-    }
-    const text = await getText(path);
-    const sourceMapMatch = getSourceMapMatch(text);
-    const parsedLine = Number.parseInt(line);
-    const parsedColumn = Number.parseInt(column);
-    const message = getErrorMessage(error);
-    const relevantStack = joinLines(lines);
-    if (sourceMapMatch) {
-      const sourceMapUrl = sourceMapMatch[1];
-      const sourceMapAbsolutePath = getSourceMapAbsolutePath(path, sourceMapUrl);
-      const sourceMap = await getJson(sourceMapAbsolutePath);
-      const {
-        source,
-        originalLine,
-        originalColumn
-      } = getOriginalPosition(sourceMap, parsedLine, parsedColumn);
-      const absoluteSourceUrl = toAbsoluteUrl(path, source);
-      const originalSourceContent = await getText(absoluteSourceUrl);
-      const codeFrame = create$1(originalSourceContent, {
-        start: {
-          line: originalLine,
-          column: originalColumn
-        },
-        end: {
-          line: originalLine,
-          column: originalColumn
-        }
-      });
-      return {
-        message,
-        codeFrame,
-        stack: relevantStack,
-        type: error.constructor.name,
-        _error: error
-      };
-    }
-    const codeFrame = create$1(text, {
-      start: {
-        line: parsedLine,
-        column: parsedColumn
-      },
-      end: {
-        line: parsedLine,
-        column: parsedColumn
-      }
-    });
-    return {
-      message,
-      codeFrame,
-      stack: relevantStack,
-      type: getType(error),
-      _error: error
-    };
-  } catch (otherError) {
-    warn(`ErrorHandling Error: ${otherError}`);
-    return error;
-  }
-};
-const prepare = async error => {
-  if (error && error.message && error.codeFrame) {
-    return prepareErrorMessageWithCodeFrame(error);
-  }
-  if (error && error.stack) {
-    return prepareErrorMessageWithoutCodeFrame(error);
-  }
-  return error;
-};
-const print = (error$1, prefix = '') => {
-  if (isFirefox) {
-    // Firefox does not support printing codeframe with error stack
-    if (error$1 && error$1._error) {
-      error(`${prefix}${error$1._error}`);
-      return;
-    }
-    error(`${prefix}${error$1}`);
-    return;
-  }
-  if (error$1 && error$1.type && error$1.message && error$1.codeFrame) {
-    error(`${prefix}${error$1.type}: ${error$1.message}\n\n${error$1.codeFrame}\n\n${error$1.stack}`);
-    return;
-  }
-  if (error$1 && error$1.message && error$1.codeFrame) {
-    error(`${prefix}${error$1.message}\n\n${error$1.codeFrame}\n\n${error$1.stack}`);
-    return;
-  }
-  if (error$1 && error$1.type && error$1.message) {
-    error(`${prefix}${error$1.type}: ${error$1.message}\n${error$1.stack}`);
-    return;
-  }
-  if (error$1 && error$1.stack) {
-    error(`${prefix}${error$1.stack}`);
-    return;
-  }
-  if (error$1 === null) {
-    error(`${prefix}null`);
-    return;
-  }
-  error(`${prefix}${error$1}`);
-};
-
-const terminate = () => {
-  globalThis.close();
-};
-
-const commandMap = {
-  'Errors.getJson': getJson,
-  'Errors.getText': getText,
-  'Errors.handleMessagePort': handleMessagePort2,
-  'Errors.prepare': prepare,
-  'Errors.print': print,
-  'Errors.terminate': terminate
-};
-
-const rpcs = Object.create(null);
-const set$d = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get = id => {
-  return rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
-const create = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$d(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-const RendererWorker$1 = 1;
-const {
-  set: set$3
-} = create(RendererWorker$1);
-const RendererWorker = {
-  __proto__: null,
-  set: set$3
-};
-
-const {
-  set
-} = RendererWorker;
-
-const listen = async () => {
-  const rpc = await WebWorkerRpcClient.create({
-    commandMap: commandMapRef
-  });
-  set(rpc);
-};
-
-const main = async () => {
-  Object.assign(commandMapRef, commandMap);
-  await listen();
-};
-
-main();