@lvce-editor/server 0.39.0 → 0.40.1

package/static/95c7ea1/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js

@@ -1,989 +0,0 @@
-const state$2 = {
-  commands: Object.create(null),
-};
-
-const registerCommand = (key, fn) => {
-  state$2.commands[key] = fn;
-};
-
-const registerCommands = (commandMap) => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
-};
-
-const getCommand = (key) => {
-  return state$2.commands[key]
-};
-
-const processName = 'extension-host-sub-worker';
-
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`[${processName}] command not found ${command}`)
-  }
-  return fn(...args)
-};
-
-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 string = (value) => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string')
-  }
-};
-
-const fn = (value) => {
-  const type = getType(value);
-  if (type !== 'function') {
-    throw new AssertionError('expected value to be of type function')
-  }
-};
-
-/**
- *
- * @param {string} string
- * @param {number|undefined} startIndex
- * @returns
- */
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf('\n', startIndex)
-};
-
-const normalizeLine = (line) => {
-  if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length)
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length)
-  }
-  return line
-};
-
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent
-  }
-  const parentNewLineIndex = getNewLineIndex(parent);
-  const childNewLineIndex = getNewLineIndex(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
-};
-
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`
-  }
-  return stringifiedError
-};
-
-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) {
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      this.code = error.code;
-    }
-  }
-}
-
-/**
- *
- * @param {string|undefined} lines
- * @returns string[]
- */
-const splitLines = (lines) => {
-  if (!lines) {
-    return []
-  }
-  return lines.split('\n')
-};
-
-const RE_AT = /^    at /;
-const RE_JUST_PATH = /^(?:\/|\\).*\:\d+$/;
-
-const isStackLine = (line) => {
-  return RE_AT.test(line)
-};
-
-const isJustPath = (line) => {
-  return RE_JUST_PATH.test(line)
-};
-
-const getModulesErrorStack = (stderr) => {
-  const lines = splitLines(stderr);
-  let startIndex = -1;
-  const extraLines = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (isJustPath(line)) {
-      extraLines.push(`    at ${line}`);
-      break
-    }
-  }
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (isStackLine(line)) {
-      startIndex = i;
-      break
-    }
-  }
-  if (startIndex === -1) {
-    return []
-  }
-  let endIndex = -1;
-  for (let i = startIndex + 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (!isStackLine(line)) {
-      endIndex = i;
-      break
-    }
-  }
-  if (endIndex === -1) {
-    endIndex = lines.length - 1;
-  }
-  const stackLines = lines.slice(startIndex, endIndex);
-  const stack = [lines[startIndex - 1], ...extraLines, ...stackLines];
-  return stack
-};
-
-const joinLines = (lines) => {
-  return lines.join('\n')
-};
-
-const cleanImportSyntaxError = (error) => {
-  const cleanStackLines = getModulesErrorStack(error.stack);
-  const cleanError = new SyntaxError(error.message);
-  const currentStack = joinLines(splitLines(new Error().stack).slice(3));
-  const cleanStack = joinLines(cleanStackLines);
-  const mergedStack = cleanStack + '\n' + currentStack;
-  cleanError.stack = mergedStack;
-  return cleanError
-};
-
-const cleanImportError = (error) => {
-  if (error && error instanceof SyntaxError) {
-    return cleanImportSyntaxError(error)
-  }
-  return error
-};
-
-const importScript = async (path) => {
-  try {
-    const module = await import(path);
-    return module
-  } catch (error) {
-    const cleanError = cleanImportError(error);
-    throw new VError(cleanError, `Failed to load ${path}`)
-  }
-};
-
-const loadFile = async (path) => {
-  string(path);
-  const module = await importScript(path);
-  if (module && module.commandMap) {
-    const commandMap = module.commandMap;
-    registerCommands(commandMap);
-  } else {
-    throw new Error(`missing commandMap export`)
-  }
-};
-
-const commandMap = {
-  'LoadFile.loadFile': loadFile,
-};
-
-const state$1 = {
-  id: 0,
-};
-
-const create$2 = () => {
-  return ++state$1.id
-};
-
-const state = {
-  callbacks: Object.create(null),
-};
-
-const registerPromise = () => {
-  const id = create$2();
-  const promise = new Promise((resolve, reject) => {
-    state.callbacks[id] = {
-      resolve,
-      reject,
-    };
-  });
-  return { id, promise }
-};
-
-const resolve = (id, args) => {
-  number(id);
-  if (!(id in state.callbacks)) {
-    console.log(args);
-    console.warn(`callback ${id} may already be disposed`);
-    return
-  }
-  state.callbacks[id].resolve(args);
-  delete state.callbacks[id];
-};
-
-const MethodNotFound = -32601;
-const Custom = -32001;
-
-const Two = '2.0';
-
-const Electron = 'electron';
-
-const Remote = 'remote';
-
-const getPlatform = () => {
-  // @ts-ignore
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-ignore
-    return PLATFORM
-  }
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return 'test'
-  }
-  // TODO find a better way to pass runtime environment
-  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
-    return Electron
-  }
-  return Remote
-};
-
-getPlatform(); // TODO tree-shake this out in production
-
-const getAssetDir = () => {
-  // @ts-ignore
-  {
-    // @ts-ignore
-    return '../../../../..'
-  }
-};
-
-const assetDir = getAssetDir();
-
-/**
- *
- * @returns {Promise<any>}
- */
-const loadKy = async () => {
-  const url = `${assetDir}/js/ky.js`;
-  const module = await import(url);
-  return module
-};
-
-const getText = async (url, options = {}) => {
-  try {
-    const { default: ky } = await loadKy();
-    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}"`)
-  }
-};
-
-// 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) {
-      if (startColumn) {
-        markerLines[startLine] = [startColumn, 0];
-      } else {
-        markerLines[startLine] = 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))
-            .replace(/[^\t]/g, ' ');
-          const numberOfMarkers = hasMarker[1] || 1;
-
-          markerLine = [
-            '\n ',
-            gutter.replace(/\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('\n');
-
-  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.message;
-  while (error.cause) {
-    error = error.cause;
-    message += `: ${error}`;
-  }
-  return message
-};
-
-const prepareErrorMessageWithCodeFrame = (error) => {
-  if (!error) {
-    return {
-      message: error,
-      stack: undefined,
-      codeFrame: undefined,
-      type: 'Error',
-    }
-  }
-  const message = getErrorMessage(error);
-  if (error.codeFrame) {
-    return {
-      message,
-      stack: error.stack,
-      codeFrame: error.codeFrame,
-      type: error.constructor.name,
-    }
-  }
-  return {
-    message,
-    stack: error.originalStack,
-    codeFrame: error.originalCodeFrame,
-    category: error.category,
-    stderr: error.stderr,
-  }
-};
-
-const RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/;
-const RE_PATH_2 = /at (.*):(\d+):(\d+)$/;
-
-/**
- *
- * @param {readonly string[]} lines
- * @returns
- */
-const getFile = (lines) => {
-  for (const line of lines) {
-    if (RE_PATH_1.test(line) || RE_PATH_2.test(line)) {
-      return line
-    }
-  }
-  return ''
-};
-
-const prepareErrorMessageWithoutCodeFrame = async (error) => {
-  try {
-    const lines = splitLines(error.stack);
-    const file = getFile(lines);
-    let match = file.match(RE_PATH_1);
-    if (!match) {
-      match = file.match(RE_PATH_2);
-    }
-    if (!match) {
-      return error
-    }
-    const [_, path, line, column] = match;
-    const text = await getText(path);
-    const parsedLine = Number.parseInt(line);
-    const parsedColumn = Number.parseInt(column);
-    const codeFrame = create$1(text, {
-      start: {
-        line: parsedLine,
-        column: parsedColumn,
-      },
-      end: {
-        line: parsedLine,
-        column: parsedColumn,
-      },
-    });
-    const relevantStack = joinLines(lines.slice(1));
-    const message = getErrorMessage(error);
-    return {
-      message,
-      codeFrame,
-      stack: relevantStack,
-      type: error.constructor.name,
-    }
-  } catch (otherError) {
-    console.warn('ErrorHandling Error');
-    console.warn(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 getErrorResponse = async (message, error) => {
-  if (error && error instanceof Error && error.message && error.message.startsWith('method not found')) {
-    return {
-      jsonrpc: Two,
-      id: message.id,
-      error: {
-        code: MethodNotFound,
-        message: error.message,
-        data: error.stack,
-      },
-    }
-  }
-  const prettyError = await prepare(error);
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error: {
-      code: Custom,
-      message: prettyError.message,
-      data: {
-        stack: prettyError.stack,
-        codeFrame: prettyError.codeFrame,
-        type: prettyError.type,
-      },
-    },
-  }
-};
-
-const getSuccessResponse = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null,
-  }
-};
-
-const getResponse = async (message, execute) => {
-  try {
-    const result = await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result)
-  } catch (error) {
-    return getErrorResponse(message, error)
-  }
-};
-
-const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
-  if ('result' in message || 'error' in message) {
-    resolve(message.id, message);
-    return
-  }
-  const response = await getResponse(message, execute);
-  ipc.send(response);
-};
-
-const handleIpc = (ipc, execute) => {
-  object(ipc);
-  fn(execute);
-  const handleMessage = (message) => {
-    return handleJsonRpcMessage(ipc, message, execute, resolve)
-  };
-  ipc.onmessage = handleMessage;
-};
-
-const MessagePort = 2;
-const ModuleWorkerAndMessagePort = 8;
-
-const Auto = () => {
-  if (globalThis.acceptPort) {
-    return MessagePort
-  }
-  if (globalThis.acceptReferencePort) {
-    return 0
-  }
-  return ModuleWorkerAndMessagePort
-};
-
-const getModule = (method) => {
-  switch (method) {
-    case MessagePort:
-      return Promise.resolve().then(function () { return IpcChildWithMessagePort; })
-    case ModuleWorkerAndMessagePort:
-      return Promise.resolve().then(function () { return IpcChildWithModuleWorkerAndMessagePort; })
-    default:
-      throw new Error('unexpected ipc type')
-  }
-};
-
-const listen$4 = async ({ method }) => {
-  const module = await getModule(method);
-  const rawIpc = await module.listen();
-  const ipc = module.wrap(rawIpc);
-  return ipc
-};
-
-const create = (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 = '\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 recreateStack = (message, stack) => {
-  if (message && !stack.includes(message)) {
-    return message + NewLine + stack
-  }
-  return stack
-};
-
-const getErrorType = (error) => {
-  if (error && error.type) {
-    return error.type
-  }
-  if (error && error.data && error.data.type) {
-    return error.data.type
-  }
-  return ''
-};
-
-const restoreJsonRpcError = (error) => {
-  if (error && error instanceof Error) {
-    return error
-  }
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    restoredError.stack = error.stack || error.data || '';
-    return restoredError
-  }
-  if (error && error.message) {
-    const type = getErrorType(error);
-    const restoredError = constructError(error.message, type, error.name);
-    const currentStack = joinLines(splitLines(new Error().stack).slice(1));
-    if (error.data) {
-      if (error.data.stack && type && error.message) {
-        restoredError.stack = type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = recreateStack(error.message, error.data.stack) + NewLine + currentStack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-    } else if (error.stack) {
-      // @ts-ignore
-      restoredError.stack = recreateStack(error.message, error.stack) + NewLine + currentStack;
-    }
-    return restoredError
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`)
-  }
-  console.log({ error });
-  return new Error(`JsonRpc Error: Unknown 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 invoke = async (ipc, method, ...params) => {
-  const { message, promise } = create(method, params);
-  ipc.send(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result
-};
-
-const listen$3 = async () => {
-  registerCommands(commandMap);
-  const ipc = await listen$4({ method: Auto() });
-  handleIpc(ipc, execute);
-  const rpc = {
-    invoke(method, ...params) {
-      return invoke(ipc, method, ...params)
-    },
-  };
-  globalThis.rpc = rpc;
-};
-
-const main = async () => {
-  await listen$3();
-};
-
-main();
-
-const listen$2 = () => {
-  const messageChannel = new MessageChannel();
-  const { port1, port2 } = messageChannel;
-  globalThis.acceptPort(port2);
-  return port1
-};
-
-const wrap$2 = (port) => {
-  return {
-    port,
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.port.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.port.onmessage
-    },
-    set onmessage(listener) {
-      this.port.onmessage = listener;
-    },
-  }
-};
-
-const IpcChildWithMessagePort = {
-  __proto__: null,
-  listen: listen$2,
-  wrap: wrap$2
-};
-
-const getData = (event) => {
-  return event.data
-};
-
-class IpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IpcError';
-  }
-}
-
-const listen$1 = async () => {
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new IpcError('module is not in web worker scope')
-  }
-  globalThis.postMessage('ready');
-  return globalThis
-};
-
-const wrap$1 = (port) => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.port.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.wrappedListener
-    },
-    set onmessage(listener) {
-      if (listener) {
-        this.wrappedListener = (event) => {
-          const actualData = getData(event);
-          listener(actualData);
-        };
-      } else {
-        this.wrappedListener = undefined;
-      }
-      this.port.onmessage = this.wrappedListener;
-    },
-  }
-};
-
-const waitForFirstMessage = async (port) => {
-  const message = await new Promise((resolve) => {
-    const cleanup = (value) => {
-      port.onmessage = null;
-      resolve(value);
-    };
-    const handleMessage = (message) => {
-      cleanup(message);
-    };
-    port.onmessage = handleMessage;
-  });
-  return message
-};
-
-const listen = async () => {
-  const parentIpcRaw = await listen$1();
-  const parentIpc = wrap$1(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') {
-    parentIpcRaw.postMessage({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null,
-    });
-    const port = firstMessage.params[1];
-    return port
-  }
-  return globalThis
-};
-
-const wrap = (port) => {
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    wrappedListener: undefined,
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transferables) {
-      this.port.postMessage(message, transferables);
-    },
-    get onmessage() {
-      return this.wrappedListener
-    },
-    set onmessage(listener) {
-      if (listener) {
-        this.wrappedListener = (event) => {
-          const actualData = getData(event);
-          listener(actualData);
-        };
-      } else {
-        this.wrappedListener = undefined;
-      }
-      this.port.onmessage = this.wrappedListener;
-    },
-  }
-};
-
-const IpcChildWithModuleWorkerAndMessagePort = {
-  __proto__: null,
-  listen,
-  wrap
-};
-//# sourceMappingURL=extensionHostSubWorkerMain.js.map