@lvce-editor/output-view 2.14.0 → 2.16.0

package/dist/outputViewWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String$1 = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -96,7 +139,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -250,7 +292,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -407,7 +456,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5 = async ({
+const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -458,11 +507,32 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5,
+  create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$2 = id => {
@@ -487,12 +557,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -516,7 +586,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -533,8 +606,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -545,55 +620,91 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  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;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   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 + error.data.stack + NewLine + 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(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -648,56 +759,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1$2 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$2(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$3 = (message, result) => {
+const create$a = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$3(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -727,35 +838,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -778,36 +889,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -816,15 +908,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$q = () => {
+const create$7 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -836,13 +927,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -878,12 +968,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -898,6 +989,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -906,6 +998,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -914,7 +1007,36 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$4 = async ({
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -931,7 +1053,8 @@ const create$4 = async ({
   messagePort.start();
   return rpc;
 };
-const create$2$1 = async ({
+
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -941,17 +1064,28 @@ const create$2$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$4({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$2$1
+
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$5({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
 };
-const create$1$1 = async ({
+
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -961,10 +1095,7 @@ const create$1$1 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$1$1
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -985,35 +1116,8 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const Log = 'log';
-const ToolBar = 'toolbar';
-
-const Button = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text$1 = 12;
-const A = 53;
-const Select$1 = 63;
-const Option$1 = 64;
-
-const Space = 9;
-const PageUp = 10;
-const PageDown = 11;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-
-const ExtensionHostWorker = 44;
-const FileSystemWorker = 209;
-const OutputWorker = 7001;
-const RendererWorker = 1;
-
 const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -1046,7 +1150,7 @@ const create$2 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$5(rpcId, mockRpc);
+      set$4(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1055,106 +1159,56 @@ const create$2 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$5(rpcId, rpc);
+      set$4(rpcId, rpc);
     }
   };
 };
 
-const {
-  invoke: invoke$3,
-  set: set$4
-} = create$2(ExtensionHostWorker);
-
-const ExtensionHost = {
-  __proto__: null,
-  invoke: invoke$3,
-  set: set$4
-};
+const ExtensionManagementWorker = 9006;
+const FileSystemWorker = 209;
+const OutputWorker = 7001;
+const RendererWorker = 1;
 
 const {
   invoke: invoke$2,
   set: set$3
+} = create$2(ExtensionManagementWorker);
+
+const {
+  invoke: invoke$1,
+  set: set$2
 } = create$2(FileSystemWorker);
 const readFile = async uri => {
-  return invoke$2('FileSystem.readFile', uri);
+  return invoke$1('FileSystem.readFile', uri);
 };
 const writeFile = async (uri, content) => {
-  return invoke$2('FileSystem.writeFile', uri, content);
+  return invoke$1('FileSystem.writeFile', uri, content);
 };
 const watchFile = async (watchId, uri, rpcId) => {
-  await invoke$2('FileSystem.watchFile', watchId, uri, rpcId);
+  await invoke$1('FileSystem.watchFile', watchId, uri, rpcId);
 };
 const unwatchFile = async watchId => {
-  await invoke$2('FileSystem.unwatchFile', watchId);
-};
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const Object$1 = 1;
-const Number$1 = 2;
-const Array$1 = 3;
-const String$1 = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown = 8;
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return Number$1;
-    case 'function':
-      return Function;
-    case 'string':
-      return String$1;
-    case 'object':
-      if (value === null) {
-        return Null;
-      }
-      if (Array.isArray(value)) {
-        return Array$1;
-      }
-      return Object$1;
-    case 'boolean':
-      return Boolean$1;
-    default:
-      return Unknown;
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== Number$1) {
-    throw new AssertionError('expected value to be of type number');
-  }
+  await invoke$1('FileSystem.unwatchFile', watchId);
 };
 
 const {
-  invoke: invoke$1,
+  invoke,
   invokeAndTransfer,
-  set: set$2
+  set: set$1
 } = create$2(RendererWorker);
 const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const activateByEvent = (event, assetDir, platform) => {
-  return invoke$1('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$1('FilePicker.showSaveFilePicker');
+  return invoke('FilePicker.showSaveFilePicker');
 };
 const getLogsDir$1 = async () => {
-  // @ts-ignore
-  return invoke$1('PlatformPaths.getLogsDir');
+  return invoke('PlatformPaths.getLogsDir');
 };
 
 const toCommandId = key => {
@@ -1242,7 +1296,7 @@ const terminate = () => {
   globalThis.close();
 };
 
-const Text = 1;
+const Text$1 = 1;
 const Link = 2;
 const LogLevel = 3;
 const RepeatCount = 4;
@@ -1265,6 +1319,11 @@ const filterItems = (items, filterValue) => {
   return items.filter(parts => getTextFromParts(parts).toLowerCase().includes(normalizedFilterValue));
 };
 
+const ExtensionOutputPrefix = 'extension-output://';
+const isExtensionOutputUri = uri => {
+  return uri.startsWith(ExtensionOutputPrefix);
+};
+
 const getAggregationKey = line => {
   return JSON.stringify(line.filter(part => part.type !== RepeatCount));
 };
@@ -1308,8 +1367,8 @@ const Actions = 'Actions';
 const Message = 'Message';
 const Viewlet = 'Viewlet';
 const Output$1 = 'Output';
-const Option = 'Option';
-const Select = 'Select';
+const Option$1 = 'Option';
+const Select$1 = 'Select';
 const Error$1 = 'Error';
 const Line = 'Line';
 const OutputRepeatCount = 'OutputRepeatCount';
@@ -1358,14 +1417,14 @@ const parseStructuredLogLine = line => {
     type: LogLevel,
     value: normalizeLevel(parsed.level)
   }, {
-    type: Text,
+    type: Text$1,
     value: parsed.message
   }];
   if (!parsed.source) {
     return parts;
   }
   return [...parts, {
-    type: Text,
+    type: Text$1,
     value: ' '
   }, {
     className: OutputSourceLink,
@@ -1403,7 +1462,7 @@ const parseLine = line => {
     if (!match) {
       if (rest) {
         parts.push({
-          type: Text,
+          type: Text$1,
           value: rest
         });
       }
@@ -1412,7 +1471,7 @@ const parseLine = line => {
     const index = rest.indexOf(match);
     if (index > 0) {
       parts.push({
-        type: Text,
+        type: Text$1,
         value: rest.slice(0, index)
       });
     }
@@ -1421,17 +1480,22 @@ const parseLine = line => {
   }
   if (parts.length === 0) {
     return [{
-      type: Text,
+      type: Text$1,
       value: ''
     }];
   }
   return parts;
 };
 
+const readOutput = async uri => {
+  if (isExtensionOutputUri(uri)) {
+    return invoke$2('Extensions.readOutputChannel', uri);
+  }
+  return readFile(uri);
+};
 const loadLines = async uri => {
   try {
-    // TODO use log stream, updating the output when the file is changed
-    const content = await readFile(uri);
+    const content = await readOutput(uri);
     const lines = aggregateLines(content.split('\n').map(parseLine));
     return {
       code: 0,
@@ -1454,6 +1518,13 @@ const loadLines = async uri => {
   }
 };
 
+const clearOutput$1 = async uri => {
+  if (isExtensionOutputUri(uri)) {
+    await invoke$2('Extensions.clearOutputChannel', uri);
+    return;
+  }
+  await writeFile(uri, '');
+};
 const clear = async state => {
   const {
     filterValue,
@@ -1468,7 +1539,7 @@ const clear = async state => {
   const {
     uri
   } = option;
-  await writeFile(uri, '');
+  await clearOutput$1(uri);
   const {
     code,
     error,
@@ -1499,7 +1570,7 @@ const {
   getCommandIds,
   getKeys,
   registerCommands,
-  set: set$1,
+  set,
   wrapCommand,
   wrapGetter
 } = create$1();
@@ -1536,7 +1607,7 @@ const create = (id, uri, x, y, width, height, platform, parentId) => {
     x,
     y
   };
-  set$1(id, state, state);
+  set(id, state, state);
 };
 
 const isEqual$2 = (oldState, newState) => {
@@ -1611,6 +1682,28 @@ const focusIndex = (state, index) => {
   };
 };
 
+const Log = 'log';
+const ToolBar = 'toolbar';
+
+const Button = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Text = 12;
+const A = 53;
+const Select = 63;
+const Option = 64;
+
+const Space = 9;
+const PageUp = 10;
+const PageDown = 11;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
@@ -1619,7 +1712,7 @@ const text = data => {
   return {
     childCount: 0,
     text: data,
-    type: Text$1
+    type: Text
   };
 };
 
@@ -1742,7 +1835,7 @@ const handleFileChange = async watchId => {
     const instance = get(key);
     if (instance.newState.watchId === watchId) {
       // @ts-ignore
-      await invoke$1('Output.refresh');
+      await invoke('Output.refresh');
     }
   }
 };
@@ -1764,7 +1857,9 @@ const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
       unregisterWatchCallback(oldWatchId);
       await unwatchFile(oldWatchId);
     }
-    // TODO dispose old watcher
+    if (isExtensionOutputUri(uri)) {
+      return;
+    }
     const rpcId = OutputWorker;
     registerWatchCallback(newWatchId, handleFileChange);
     await watchFile(newWatchId, uri, rpcId);
@@ -1791,7 +1886,7 @@ const selectChannel = async (state, id) => {
   } = await loadLines(matchingOption.uri);
 
   // TODO memory leak and race condition, need to dispose file watcher of previous uri
-  const newWatchId = createWatchId();
+  const newWatchId = isExtensionOutputUri(matchingOption.uri) ? 0 : createWatchId();
   await setupChangeListener(watchId, newWatchId, matchingOption.uri);
   const filteredItems = filterItems(lines, filterValue);
   return {
@@ -1813,34 +1908,21 @@ const handleSourceLinkClick = async (state, uri) => {
   if (!uri) {
     return state;
   }
-  await invoke$1('Main.openUri', uri);
+  await invoke('Main.openUri', uri);
   return state;
 };
 
-const sendMessagePortToExtensionHostWorker2 = async port => {
-  await sendMessagePortToExtensionHostWorker(port);
-};
-
-const createExtensionHostRpc = async () => {
-  try {
-    const rpc = await TransferMessagePortRpcParent.create({
-      commandMap: {},
-      send: sendMessagePortToExtensionHostWorker2
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
+const createExtensionManagementWorkerRpc = async () => {
+  const rpc = await create$4({
+    commandMap: {},
+    send: port => sendMessagePortToExtensionManagementWorker(port, OutputWorker)
+  });
+  return rpc;
 };
 
-const {
-  invoke,
-  set
-} = ExtensionHost;
-
-const initializeExtensionHost = async () => {
-  const extensionHostRpc = await createExtensionHostRpc();
-  set(extensionHostRpc);
+const initializeExtensionManagementWorker = async () => {
+  const rpc = await createExtensionManagementWorkerRpc();
+  set$3(rpc);
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
@@ -1849,7 +1931,7 @@ const sendMessagePortToFileSystemWorker = async port => {
 
 const createFileSystemWorkerRpc = async () => {
   try {
-    const rpc = await TransferMessagePortRpcParent.create({
+    const rpc = await create$5({
       commandMap: {},
       send: sendMessagePortToFileSystemWorker
     });
@@ -1861,11 +1943,11 @@ const createFileSystemWorkerRpc = async () => {
 
 const initializeFileSystemWorker = async () => {
   const rpc = await createFileSystemWorkerRpc();
-  set$3(rpc);
+  set$2(rpc);
 };
 
 const initialize = async () => {
-  await Promise.all([initializeFileSystemWorker(), initializeExtensionHost()]);
+  await Promise.all([initializeFileSystemWorker(), initializeExtensionManagementWorker()]);
 };
 
 const Web = 1;
@@ -1936,13 +2018,7 @@ const error = error => {
 
 const getExtensionOptions = async () => {
   try {
-    // TODO make api more declarative:
-    // output channels are registered in extension manifest
-    // only downside: it might show channels for extensions that are not active
-    // @ts-ignore
-    await activateByEvent('onOutput');
-    // @ts-ignore
-    const channels = await invoke('Output.getEnabledProviders');
+    const channels = await invoke$2('Extensions.getOutputChannelProviders');
     return channels;
   } catch (error$1) {
     error(error$1);
@@ -2046,7 +2122,7 @@ const loadContent = async (state, savedState) => {
     lines
   } = await loadLines(uri);
   const filteredItems = filterItems(lines, filterValue);
-  const newWatchId = createWatchId();
+  const newWatchId = isExtensionOutputUri(uri) ? 0 : createWatchId();
   await setupChangeListener(watchId, newWatchId, uri);
   const buttons = loadButtons();
   return {
@@ -2153,7 +2229,7 @@ const getLinePartDom = part => {
         childCount: 2,
         nodes: [repeatCountNode, text(part.value), spaceNode]
       };
-    case Text:
+    case Text$1:
       return {
         childCount: 1,
         nodes: [text(part.value)]
@@ -2273,7 +2349,7 @@ const render2 = (uid, diffResult) => {
     newState,
     oldState
   } = get(uid);
-  set$1(uid, newState, newState);
+  set(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2325,8 +2401,8 @@ const getOptionVirtualDom = option => {
   } = option;
   return [{
     childCount: 1,
-    className: Option,
-    type: Option$1,
+    className: Option$1,
+    type: Option,
     value: id
   }, text(label)];
 };
@@ -2334,10 +2410,10 @@ const getOptionVirtualDom = option => {
 const getSelectVirtualDom = options => {
   return [{
     childCount: options.length,
-    className: Select,
+    className: Select$1,
     name: Output,
     onChange: HandleSelect,
-    type: Select$1
+    type: Select
   }, ...options.flatMap(getOptionVirtualDom)];
 };
 
@@ -2499,10 +2575,10 @@ const commandMapRef = {};
 const listen = async () => {
   registerCommands(commandMap);
   Object.assign(commandMapRef, commandMap);
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$3({
     commandMap: commandMapRef
   });
-  set$2(rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/output-view",
-  "version": "2.14.0",
+  "version": "2.16.0",
   "description": "Output View Worker",
   "repository": {
     "type": "git",