@lvce-editor/extension-host-worker 8.20.0 → 8.25.0

package/dist/extension-api/index.js

@@ -847,7 +847,7 @@ var createRpc = (ipc) => {
     fn(response);
     delete callbacks2[id2];
   };
-  const rpc2 = {
+  const rpc = {
     async dispose() {
       await ipc?.dispose();
     },
@@ -867,7 +867,7 @@ var createRpc = (ipc) => {
       ipc.send(message);
     }
   };
-  return rpc2;
+  return rpc;
 };
 
 // packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/HandleMessage/HandleMessage.js
@@ -917,9 +917,9 @@ var create5 = async ({ commandMap: commandMap5, isMessagePortOpen = true, messag
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
-  const rpc2 = createRpc(ipc);
+  const rpc = createRpc(ipc);
   messagePort.start();
-  return rpc2;
+  return rpc;
 };
 
 // packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/WebWorkerRpcClient/WebWorkerRpcClient.js
@@ -931,8 +931,417 @@ var create6 = async ({ commandMap: commandMap5 }) => {
   register(commandMap5);
   const ipc = await listen(IpcChildWithModuleWorkerAndMessagePort$1);
   handleIpc(ipc);
-  const rpc2 = createRpc(ipc);
-  return rpc2;
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/CreateMockRpc/CreateMockRpc.js
+var createMockRpc = ({ commandMap: commandMap5 }) => {
+  const invocations = [];
+  const invoke2 = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap5[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke: invoke2,
+    invokeAndTransfer: invoke2
+  };
+  return mockRpc;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc-registry/dist/parts/RpcRegistry/RpcRegistry.js
+var rpcs = /* @__PURE__ */ Object.create(null);
+var set = (id2, rpc) => {
+  rpcs[id2] = rpc;
+};
+var get2 = (id2) => {
+  return rpcs[id2];
+};
+var remove2 = (id2) => {
+  delete rpcs[id2];
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc-registry/dist/parts/RpcFactory/RpcFactory.js
+var create7 = (rpcId) => {
+  return {
+    async dispose() {
+      const rpc = get2(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get2(rpcId);
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get2(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap5) {
+      const mockRpc = createMockRpc({ commandMap: commandMap5 });
+      set(rpcId, mockRpc);
+      mockRpc[Symbol.dispose] = () => {
+        remove2(rpcId);
+      };
+      return mockRpc;
+    },
+    set(rpc) {
+      set(rpcId, rpc);
+    }
+  };
+};
+
+// packages/extension-api/node_modules/@lvce-editor/constants/dist/parts/VirtualDomElements/VirtualDomElements.js
+var VirtualDomElements_exports = {};
+__export(VirtualDomElements_exports, {
+  A: () => A,
+  Abbr: () => Abbr,
+  Article: () => Article,
+  Aside: () => Aside,
+  Audio: () => Audio,
+  BlockQuote: () => BlockQuote,
+  Br: () => Br,
+  Button: () => Button,
+  Canvas: () => Canvas,
+  Circle: () => Circle,
+  Cite: () => Cite,
+  Code: () => Code,
+  Col: () => Col,
+  ColGroup: () => ColGroup,
+  Data: () => Data,
+  Dd: () => Dd,
+  Defs: () => Defs,
+  Del: () => Del,
+  Div: () => Div,
+  Dl: () => Dl,
+  Dt: () => Dt,
+  Ellipse: () => Ellipse,
+  Em: () => Em,
+  Figcaption: () => Figcaption,
+  Figure: () => Figure,
+  Footer: () => Footer,
+  Form: () => Form,
+  G: () => G,
+  H1: () => H1,
+  H2: () => H2,
+  H3: () => H3,
+  H4: () => H4,
+  H5: () => H5,
+  H6: () => H6,
+  Head: () => Head,
+  Header: () => Header,
+  Hr: () => Hr,
+  Html: () => Html,
+  I: () => I,
+  Iframe: () => Iframe,
+  Img: () => Img,
+  Input: () => Input,
+  Ins: () => Ins,
+  Kbd: () => Kbd,
+  Label: () => Label,
+  Li: () => Li,
+  Line: () => Line,
+  Main: () => Main,
+  Meta: () => Meta,
+  Nav: () => Nav,
+  Ol: () => Ol,
+  Option: () => Option,
+  P: () => P,
+  Path: () => Path,
+  Polygon: () => Polygon,
+  Polyline: () => Polyline,
+  Pre: () => Pre,
+  Quote: () => Quote,
+  Rect: () => Rect,
+  Reference: () => Reference,
+  Root: () => Root,
+  Search: () => Search,
+  Section: () => Section,
+  Select: () => Select,
+  Span: () => Span,
+  Strong: () => Strong,
+  Style: () => Style,
+  Svg: () => Svg,
+  TBody: () => TBody,
+  THead: () => THead,
+  Table: () => Table,
+  Td: () => Td,
+  Text: () => Text,
+  TextArea: () => TextArea,
+  Tfoot: () => Tfoot,
+  Th: () => Th,
+  Time: () => Time,
+  Title: () => Title,
+  Tr: () => Tr,
+  Ul: () => Ul,
+  Use: () => Use,
+  Video: () => Video
+});
+var Audio = 0;
+var Button = 1;
+var Col = 2;
+var ColGroup = 3;
+var Div = 4;
+var H1 = 5;
+var Input = 6;
+var Kbd = 7;
+var Span = 8;
+var Table = 9;
+var TBody = 10;
+var Td = 11;
+var Text = 12;
+var Th = 13;
+var THead = 14;
+var Tr = 15;
+var I = 16;
+var Img = 17;
+var Root = 0;
+var Ins = 20;
+var Del = 21;
+var H2 = 22;
+var H3 = 23;
+var H4 = 24;
+var H5 = 25;
+var H6 = 26;
+var Article = 27;
+var Aside = 28;
+var Footer = 29;
+var Header = 30;
+var Nav = 40;
+var Section = 41;
+var Search = 42;
+var Dd = 43;
+var Dl = 44;
+var Figcaption = 45;
+var Figure = 46;
+var Hr = 47;
+var Li = 48;
+var Ol = 49;
+var P = 50;
+var Pre = 51;
+var A = 53;
+var Abbr = 54;
+var Br = 55;
+var Cite = 56;
+var Data = 57;
+var Time = 58;
+var Tfoot = 59;
+var Ul = 60;
+var Video = 61;
+var TextArea = 62;
+var Select = 63;
+var Option = 64;
+var Code = 65;
+var Label = 66;
+var Dt = 67;
+var Iframe = 68;
+var Main = 69;
+var Strong = 70;
+var Em = 71;
+var Style = 72;
+var Html = 73;
+var Head = 74;
+var Title = 75;
+var Meta = 76;
+var Canvas = 77;
+var Form = 78;
+var BlockQuote = 79;
+var Quote = 80;
+var Circle = 81;
+var Defs = 82;
+var Ellipse = 83;
+var G = 84;
+var Line = 85;
+var Path = 86;
+var Polygon = 87;
+var Polyline = 88;
+var Rect = 89;
+var Svg = 90;
+var Use = 91;
+var Reference = 100;
+
+// packages/extension-api/node_modules/@lvce-editor/constants/dist/parts/RpcId/RpcId.js
+var RpcId_exports = {};
+__export(RpcId_exports, {
+  AuthProcess: () => AuthProcess,
+  AuthWorker: () => AuthWorker,
+  BlobWorker: () => BlobWorker,
+  ChatCoordinatorWorker: () => ChatCoordinatorWorker,
+  ChatDebugWorker: () => ChatDebugWorker,
+  ChatMathWorker: () => ChatMathWorker,
+  ChatMessageParsingWorker: () => ChatMessageParsingWorker,
+  ChatNetworkWorker: () => ChatNetworkWorker,
+  ChatStorageWorker: () => ChatStorageWorker,
+  ChatToolWorker: () => ChatToolWorker,
+  ChatViewModelWorker: () => ChatViewModelWorker,
+  Cli: () => Cli,
+  ClipBoardProcess: () => ClipBoardProcess,
+  ClipBoardWorker: () => ClipBoardWorker,
+  ColorPickerWorker: () => ColorPickerWorker,
+  CompletionWorker: () => CompletionWorker,
+  DebugWorker: () => DebugWorker,
+  EditorWorker: () => EditorWorker,
+  EmbedsProcess: () => EmbedsProcess,
+  EmbedsWorker: () => EmbedsWorker,
+  ErrorWorker: () => ErrorWorker,
+  ExtensionDetailWorker: () => ExtensionDetailWorker,
+  ExtensionHostHelperProcess: () => ExtensionHostHelperProcess,
+  ExtensionHostWorker: () => ExtensionHostWorker,
+  ExtensionManagementWorker: () => ExtensionManagementWorker,
+  FileSearchWorker: () => FileSearchWorker,
+  FileSystemProcess: () => FileSystemProcess,
+  FileSystemWorker: () => FileSystemWorker,
+  FileWatcherProcess: () => FileWatcherProcess,
+  FindWidgetWorker: () => FindWidgetWorker,
+  GithubWorker: () => GithubWorker,
+  HoverWorker: () => HoverWorker,
+  IconThemeWorker: () => IconThemeWorker,
+  IframeWorker: () => IframeWorker,
+  MainAreaWorker: () => MainAreaWorker,
+  MainProcess: () => MainProcess,
+  MarkdownWorker: () => MarkdownWorker,
+  OpenerWorker: () => OpenerWorker,
+  OutputWorker: () => OutputWorker,
+  PreviewSandBoxWorker: () => PreviewSandBoxWorker,
+  PreviewWorker: () => PreviewWorker,
+  ProblemsWorker: () => ProblemsWorker,
+  ProcessExplorerRenderer: () => ProcessExplorerRenderer,
+  QuickPickWorker: () => QuickPickWorker,
+  RenameWorker: () => RenameWorker,
+  RendererProcess: () => RendererProcess,
+  RendererWorker: () => RendererWorker,
+  SearchProcess: () => SearchProcess,
+  SearchProcessElectron: () => SearchProcessElectron,
+  SettingsWorker: () => SettingsWorker,
+  SharedProcess: () => SharedProcess,
+  SourceActionWorker: () => SourceActionWorker,
+  SourceControlWorker: () => SourceControlWorker,
+  StatusBarWorker: () => StatusBarWorker,
+  SyntaxHighlightingWorker: () => SyntaxHighlightingWorker,
+  TemplateWorker: () => TemplateWorker,
+  TerminalProcess: () => TerminalProcess,
+  TestWithPlaywrightCli: () => TestWithPlaywrightCli,
+  TestWithPlaywrightWorker: () => TestWithPlaywrightWorker,
+  TestWorker: () => TestWorker,
+  TextMeasurementWorker: () => TextMeasurementWorker,
+  TextSearchWorker: () => TextSearchWorker,
+  TypescriptCompileProcess: () => TypescriptCompileProcess
+});
+var AuthProcess = 6040;
+var AuthWorker = 6010;
+var BlobWorker = 19e3;
+var ChatCoordinatorWorker = 6008;
+var ChatDebugWorker = 6006;
+var ChatMathWorker = 6007;
+var ChatMessageParsingWorker = 6009;
+var ChatNetworkWorker = 6002;
+var ChatStorageWorker = 6003;
+var ChatToolWorker = 6005;
+var ChatViewModelWorker = 6022;
+var Cli = 6004;
+var ClipBoardProcess = 3401;
+var ClipBoardWorker = 3400;
+var ColorPickerWorker = 302;
+var CompletionWorker = 301;
+var DebugWorker = 55;
+var EditorWorker = 99;
+var EmbedsProcess = 207;
+var EmbedsWorker = 208;
+var ErrorWorker = 3308;
+var ExtensionDetailWorker = 3402;
+var ExtensionHostHelperProcess = 3;
+var ExtensionHostWorker = 44;
+var ExtensionManagementWorker = 9006;
+var FileSearchWorker = 7013;
+var FileSystemProcess = 210;
+var FileSystemWorker = 209;
+var FileWatcherProcess = 220;
+var FindWidgetWorker = 9002;
+var GithubWorker = 4444;
+var HoverWorker = 9003;
+var IconThemeWorker = 7009;
+var IframeWorker = 344;
+var MainAreaWorker = 82221;
+var MainProcess = -5;
+var MarkdownWorker = 300;
+var OpenerWorker = 4561;
+var OutputWorker = 7001;
+var PreviewSandBoxWorker = 3212;
+var PreviewWorker = 3211;
+var ProblemsWorker = 3403;
+var ProcessExplorerRenderer = 33;
+var QuickPickWorker = 1e4;
+var RenameWorker = 9004;
+var RendererProcess = 1670;
+var RendererWorker = 1;
+var SearchProcess = 77;
+var SearchProcessElectron = 2;
+var SettingsWorker = 11010;
+var SharedProcess = 1492;
+var SourceActionWorker = 303;
+var SourceControlWorker = 66;
+var StatusBarWorker = 7201;
+var SyntaxHighlightingWorker = 3309;
+var TemplateWorker = 4445;
+var TerminalProcess = 7;
+var TestWithPlaywrightCli = 6e3;
+var TestWithPlaywrightWorker = 6001;
+var TestWorker = 9001;
+var TextMeasurementWorker = 7011;
+var TextSearchWorker = 7010;
+var TypescriptCompileProcess = 221;
+
+// packages/extension-api/node_modules/@lvce-editor/rpc-registry/dist/parts/ExtensionManagementWorker/ExtensionManagementWorker.js
+var ExtensionManagementWorker_exports = {};
+__export(ExtensionManagementWorker_exports, {
+  disable: () => disable,
+  disable2: () => disable2,
+  dispose: () => dispose,
+  enable: () => enable,
+  enable2: () => enable2,
+  getExtension: () => getExtension,
+  getLanguages: () => getLanguages,
+  install: () => install,
+  invalidateExtensionsCache: () => invalidateExtensionsCache,
+  invoke: () => invoke,
+  invokeAndTransfer: () => invokeAndTransfer,
+  registerMockRpc: () => registerMockRpc,
+  set: () => set2,
+  uninstall: () => uninstall
+});
+var { dispose, invoke, invokeAndTransfer, registerMockRpc, set: set2 } = create7(RpcId_exports.ExtensionManagementWorker);
+var enable = (id2) => {
+  return invoke(`Extensions.enable`, id2);
+};
+var enable2 = (id2, platform) => {
+  return invoke(`Extensions.enable2`, id2, platform);
+};
+var disable = (id2) => {
+  return invoke(`Extensions.disable`, id2);
+};
+var disable2 = (id2, platform) => {
+  return invoke(`Extensions.disable2`, id2, platform);
+};
+var getExtension = (id2) => {
+  return invoke(`Extensions.getExtension`, id2);
+};
+var getLanguages = (platform, assetDir) => {
+  return invoke("Extensions.getLanguages", platform, assetDir);
+};
+var install = (id2) => {
+  return invoke(`Extensions.install`, id2);
+};
+var uninstall = (id2) => {
+  return invoke(`Extensions.uninstall`, id2);
+};
+var invalidateExtensionsCache = () => {
+  return invoke(`Extensions.invalidateExtensionsCache`);
 };
 
 // packages/extension-api/src/parts/ExtensionApiError/ExtensionApiError.ts
@@ -975,7 +1384,9 @@ var registerCommand = (command) => {
 };
 var getCommandRegistrySnapshot = () => {
   return {
-    commands: Object.values(commands2)
+    commands: Object.values(commands2).map((command) => ({
+      id: command.id
+    }))
   };
 };
 var executeCommand = async (id2, ...args) => {
@@ -1089,16 +1500,40 @@ var getType = (value) => {
   }
   return typeof value;
 };
+var sanitizeCompletionItem = (item) => {
+  const sanitizedItem = {};
+  for (const [key, value] of Object.entries(item)) {
+    if (typeof value !== "function") {
+      sanitizedItem[key] = value;
+    }
+  }
+  const { kind: itemKind, type } = item;
+  let kind = 0;
+  if (typeof itemKind === "number") {
+    kind = itemKind;
+  } else if (typeof type === "number") {
+    kind = type;
+  }
+  return {
+    ...sanitizedItem,
+    flags: typeof item.flags === "number" ? item.flags : 0,
+    kind,
+    label: typeof item.label === "string" ? item.label : "",
+    matches: Array.isArray(item.matches) ? item.matches : []
+  };
+};
 var validateCompletionResult = (completion) => {
   if (!Array.isArray(completion)) {
     throw new ExtensionApiError(`invalid completion result: completion must be of type array but is ${getType(completion)}`);
   }
+  const completionItems = [];
   for (const item of completion) {
     if (!item || typeof item !== "object" || Array.isArray(item)) {
       throw new ExtensionApiError(`invalid completion result: expected completion item to be of type object but was of type ${getType(item)}`);
     }
+    completionItems.push(sanitizeCompletionItem(item));
   }
-  return completion;
+  return completionItems;
 };
 var registry = createProviderRegistry({
   mapProvider(provider) {
@@ -1143,7 +1578,10 @@ var executeResolveCompletionItemProvider = async (textDocument, offset, name, co
 var getCompletionProviders = registry.getProviders;
 var getCompletionProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetCompletionProviderRegistry = registry.reset;
@@ -1201,7 +1639,10 @@ var executeDiagnosticProvider = async (textDocument, ...args) => {
 var getDiagnosticProviders = registry2.getProviders;
 var getDiagnosticProviderRegistrySnapshot = () => {
   return {
-    providers: registry2.getProviders()
+    providers: registry2.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetDiagnosticProviderRegistry = registry2.reset;
@@ -1236,26 +1677,17 @@ var executeFormattingProvider = async (textDocument, ...args) => {
 var getFormattingProviders = registry3.getProviders;
 var getFormattingProviderRegistrySnapshot = () => {
   return {
-    providers: registry3.getProviders()
+    providers: registry3.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetFormattingProviderRegistry = registry3.reset;
 
-// packages/extension-api/src/parts/Rpc/Rpc.ts
-var rpc;
-var set = (value) => {
-  rpc = value;
-};
-var invoke = async (method, ...params) => {
-  if (!rpc) {
-    return void 0;
-  }
-  return rpc.invoke(method, ...params);
-};
-
 // packages/extension-api/src/parts/NotifyStatusBarChange/NotifyStatusBarChange.ts
 var notifyStatusBarChange = async (id2) => {
-  await invoke("StatusBar.handleChange", id2);
+  await ExtensionManagementWorker_exports.invoke("StatusBar.handleChange", id2);
 };
 
 // packages/extension-api/src/parts/StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.ts
@@ -1297,7 +1729,9 @@ var getStatusBarItems = () => {
 };
 var getStatusBarItemProviderRegistrySnapshot = () => {
   return {
-    providers: registry4.getProviders()
+    providers: registry4.getProviders().map((provider) => ({
+      id: provider.id
+    }))
   };
 };
 var resetStatusBarItemProviderRegistry = registry4.reset;
@@ -1353,25 +1787,484 @@ var executeHoverProvider = async (textDocument, offset, ...args) => {
 var getHoverProviders = registry5.getProviders;
 var getHoverProviderRegistrySnapshot = () => {
   return {
-    providers: registry5.getProviders()
+    providers: registry5.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetHoverProviderRegistry = registry5.reset;
 
+// packages/extension-api/src/parts/OutputChannel/OutputChannel.ts
+var outputChannels = /* @__PURE__ */ Object.create(null);
+var isActivated = false;
+var RE_DASH_CASE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var assertOutputChannelId = (id2) => {
+  if (typeof id2 !== "string" || id2.length === 0) {
+    throw new ExtensionApiError("output channel id is required");
+  }
+  if (!RE_DASH_CASE.test(id2)) {
+    throw new ExtensionApiError(`output channel id ${id2} must be dash-case`);
+  }
+};
+var assertCanWrite = (id2) => {
+  if (!isActivated) {
+    throw new ExtensionApiError(`output channel ${id2} cannot be written before activate`);
+  }
+};
+var ExtensionOutputChannel = class {
+  #id;
+  constructor(id2) {
+    this.#id = id2;
+  }
+  async append(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.appendOutputChannel", this.#id, text);
+  }
+  async appendLine(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.appendOutputChannel", this.#id, `${text}
+`);
+  }
+  async clear() {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.clearOutputChannel", this.#id);
+  }
+  async replace(text) {
+    assertCanWrite(this.#id);
+    await ExtensionManagementWorker_exports.invoke("ExtensionApi.replaceOutputChannel", this.#id, text);
+  }
+};
+var activateOutputChannels = () => {
+  isActivated = true;
+};
+var createOutputChannel = (id2) => {
+  assertOutputChannelId(id2);
+  if (id2 in outputChannels) {
+    throw new ExtensionApiError(`output channel ${id2} is already created`);
+  }
+  outputChannels[id2] = {
+    id: id2
+  };
+  return new ExtensionOutputChannel(id2);
+};
+var getOutputChannelRegistrySnapshot = () => {
+  return {
+    outputChannels: Object.values(outputChannels)
+  };
+};
+var resetOutputChannelRegistry = () => {
+  for (const id2 of Object.keys(outputChannels)) {
+    delete outputChannels[id2];
+  }
+  isActivated = false;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/PatchType/PatchType.js
+var SetText = 1;
+var Replace = 2;
+var SetAttribute = 3;
+var RemoveAttribute = 4;
+var Add = 6;
+var NavigateChild = 7;
+var NavigateParent = 8;
+var RemoveChild = 9;
+var NavigateSibling = 10;
+var SetReferenceNodeUid = 11;
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/IsKey/IsKey.js
+var isKey = (key) => {
+  return key !== "type" && key !== "childCount";
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/GetKeys/GetKeys.js
+var getKeys = (node) => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomTree/VirtualDomTree.js
+var arrayToTree = (nodes) => {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const { children, nodesConsumed } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+    result.push({
+      node,
+      children
+    });
+    i += 1 + nodesConsumed;
+  }
+  return result;
+};
+var getChildrenWithCount = (nodes, startIndex, childCount) => {
+  if (childCount === 0) {
+    return { children: [], nodesConsumed: 0 };
+  }
+  const children = [];
+  let i = startIndex;
+  let remaining = childCount;
+  let totalConsumed = 0;
+  while (remaining > 0 && i < nodes.length) {
+    const node = nodes[i];
+    const nodeChildCount = node.childCount || 0;
+    const { children: nodeChildren, nodesConsumed } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+    children.push({
+      node,
+      children: nodeChildren
+    });
+    const nodeSize = 1 + nodesConsumed;
+    i += nodeSize;
+    totalConsumed += nodeSize;
+    remaining--;
+  }
+  return { children, nodesConsumed: totalConsumed };
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/CompareNodes.js
+var compareNodes = (oldNode, newNode) => {
+  if (oldNode.type !== newNode.type) {
+    return null;
+  }
+  const patches = [];
+  if (oldNode.type === VirtualDomElements_exports.Reference) {
+    if (oldNode.uid !== newNode.uid) {
+      patches.push({
+        type: SetReferenceNodeUid,
+        uid: newNode.uid
+      });
+    }
+    return patches;
+  }
+  if (oldNode.type === VirtualDomElements_exports.Text && newNode.type === VirtualDomElements_exports.Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
+    }
+    return patches;
+  }
+  const oldKeys = getKeys(oldNode);
+  const newKeys = getKeys(newNode);
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
+  }
+  for (const key of oldKeys) {
+    if (!Object.hasOwn(newNode, key)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
+    }
+  }
+  return patches;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/TreeToArray.js
+var treeToArray = (node) => {
+  const result = [node.node];
+  for (const child of node.children) {
+    result.push(...treeToArray(child));
+  }
+  return result;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/DiffTrees.js
+var navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+var navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+var addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+var replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+var diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex2 = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex2;
+  }
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  return nextChildIndex;
+};
+var diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
+var diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  let currentChildIndex = -1;
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
+      indicesToRemove.push(i);
+      continue;
+    }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
+  }
+  navigateToParent(patches, currentChildIndex);
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
+  }
+};
+var diffTrees = (oldTree, newTree, patches, path) => {
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
+  }
+  diffChildren(oldTree, newTree, patches);
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/RemoveTrailingNavigationPatches.js
+var removeTrailingNavigationPatches = (patches) => {
+  let lastNonNavigationIndex = -1;
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
+      lastNonNavigationIndex = i;
+      break;
+    }
+  }
+  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/VirtualDomDiffTree.js
+var diffTree = (oldNodes, newNodes) => {
+  const oldTree = arrayToTree(oldNodes);
+  const newTree = arrayToTree(newNodes);
+  const patches = [];
+  diffTrees(oldTree, newTree, patches, []);
+  return removeTrailingNavigationPatches(patches);
+};
+
+// packages/extension-api/src/parts/ViewRegistry/ViewRegistry.ts
+var views = /* @__PURE__ */ Object.create(null);
+var instances = /* @__PURE__ */ Object.create(null);
+var renderedDoms = /* @__PURE__ */ Object.create(null);
+var assertView = (view) => {
+  if (!view) {
+    throw new ExtensionApiError("view is not defined");
+  }
+  if (typeof view.id !== "string" || view.id.length === 0) {
+    throw new ExtensionApiError("view is missing id");
+  }
+  if (typeof view.create !== "function") {
+    throw new ExtensionApiError(`view ${view.id} is missing create function`);
+  }
+  if (view.id in views) {
+    throw new ExtensionApiError(`view ${view.id} is already registered`);
+  }
+};
+var toRegisteredView = (view) => {
+  const registeredView = {
+    icon: view.icon,
+    id: view.id,
+    title: view.title
+  };
+  if (view.kind) {
+    return {
+      ...registeredView,
+      kind: view.kind
+    };
+  }
+  return registeredView;
+};
+var registerView = (view) => {
+  assertView(view);
+  views[view.id] = view;
+  return {
+    dispose() {
+      delete views[view.id];
+    }
+  };
+};
+var executeViewProvider = (id2) => {
+  const view = views[id2];
+  if (!view) {
+    throw new ExtensionApiError(`view ${id2} not found`);
+  }
+  return view.create();
+};
+var assertVirtualDomViewInstance = (id2, instance) => {
+  if (!instance || typeof instance !== "object") {
+    throw new ExtensionApiError(`view ${id2} did not return a view instance`);
+  }
+  if (typeof instance.render !== "function") {
+    throw new ExtensionApiError(`view ${id2} instance is missing render function`);
+  }
+};
+var getVirtualDomInstance = (uid) => {
+  const instance = instances[uid];
+  if (!instance) {
+    throw new ExtensionApiError(`view instance ${uid} not found`);
+  }
+  return instance;
+};
+var renderDom = async (instance) => {
+  const dom = await instance.render();
+  if (!Array.isArray(dom)) {
+    throw new ExtensionApiError("view render result must be an array");
+  }
+  return dom;
+};
+var createViewInstance = async (viewId, uid, context) => {
+  const view = views[viewId];
+  if (!view) {
+    throw new ExtensionApiError(`view ${viewId} not found`);
+  }
+  if (view.kind !== "virtualDom") {
+    throw new ExtensionApiError(`view ${viewId} is not a virtual dom view`);
+  }
+  const instance = await view.create({
+    ...context,
+    uid,
+    viewId
+  });
+  assertVirtualDomViewInstance(viewId, instance);
+  instances[uid] = instance;
+  const dom = await renderDom(instance);
+  renderedDoms[uid] = dom;
+  return {
+    dom,
+    type: "setDom"
+  };
+};
+var dispatchViewEvent = async (uid, event) => {
+  const instance = getVirtualDomInstance(uid);
+  if (typeof instance.handleEvent === "function") {
+    await instance.handleEvent(event);
+  }
+  const oldDom = renderedDoms[uid] || [];
+  const newDom = await renderDom(instance);
+  renderedDoms[uid] = newDom;
+  const patches = diffTree(oldDom, newDom);
+  return {
+    patches,
+    type: "setPatches"
+  };
+};
+var disposeViewInstance = async (uid) => {
+  const instance = instances[uid];
+  if (instance && typeof instance.dispose === "function") {
+    await instance.dispose();
+  }
+  delete instances[uid];
+  delete renderedDoms[uid];
+};
+var saveViewInstanceState = async (uid) => {
+  const instance = getVirtualDomInstance(uid);
+  if (typeof instance.saveState !== "function") {
+    return void 0;
+  }
+  return instance.saveState();
+};
+var getViewRegistrySnapshot = () => {
+  return {
+    views: Object.values(views).map(toRegisteredView)
+  };
+};
+var resetViewRegistry = () => {
+  for (const id2 of Object.keys(views)) {
+    delete views[id2];
+  }
+  for (const uid of Object.keys(instances)) {
+    delete instances[Number(uid)];
+  }
+  for (const uid of Object.keys(renderedDoms)) {
+    delete renderedDoms[Number(uid)];
+  }
+};
+
 // packages/extension-api/src/parts/ExtensionApiCommandMap/ExtensionApiCommandMap.ts
 var commandMap = {
+  "ExtensionApi.createViewInstance": createViewInstance,
+  "ExtensionApi.dispatchViewEvent": dispatchViewEvent,
+  "ExtensionApi.disposeViewInstance": disposeViewInstance,
   "ExtensionApi.executeCommand": executeCommand,
   "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
   "ExtensionApi.executeDiagnosticProvider": executeDiagnosticProvider,
   "ExtensionApi.executeFormattingProvider": executeFormattingProvider,
   "ExtensionApi.executeHoverProvider": executeHoverProvider,
   "ExtensionApi.executeResolveCompletionItemProvider": executeResolveCompletionItemProvider,
+  "ExtensionApi.executeViewProvider": executeViewProvider,
   "ExtensionApi.getCommandRegistrySnapshot": getCommandRegistrySnapshot,
   "ExtensionApi.getCompletionProviderRegistrySnapshot": getCompletionProviderRegistrySnapshot,
   "ExtensionApi.getDiagnosticProviderRegistrySnapshot": getDiagnosticProviderRegistrySnapshot,
   "ExtensionApi.getFormattingProviderRegistrySnapshot": getFormattingProviderRegistrySnapshot,
   "ExtensionApi.getHoverProviderRegistrySnapshot": getHoverProviderRegistrySnapshot,
-  "ExtensionApi.getStatusBarItems": getStatusBarItems
+  "ExtensionApi.getOutputChannelRegistrySnapshot": getOutputChannelRegistrySnapshot,
+  "ExtensionApi.getStatusBarItems": getStatusBarItems,
+  "ExtensionApi.getViewRegistrySnapshot": getViewRegistrySnapshot,
+  "ExtensionApi.saveViewInstanceState": saveViewInstanceState
 };
 
 // packages/extension-api/src/parts/ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.ts
@@ -1406,10 +2299,10 @@ var commandMap3 = {
 
 // packages/extension-api/src/parts/ExtensionApiWorkerListen/ExtensionApiWorkerListen.ts
 var listen2 = async () => {
-  const rpc2 = WebWorkerRpcClient_exports.create({
+  const rpc = WebWorkerRpcClient_exports.create({
     commandMap: commandMap3
   });
-  return rpc2;
+  return rpc;
 };
 
 // packages/extension-api/src/parts/Activation/Activation.ts
@@ -1418,18 +2311,19 @@ var activate = async () => {
   if (!rpcPromise) {
     rpcPromise = listen2();
   }
-  const rpc2 = await rpcPromise;
-  set(rpc2);
+  const rpc = await rpcPromise;
+  ExtensionManagementWorker_exports.set(rpc);
+  activateOutputChannels();
 };
 
 // packages/extension-api/src/parts/ExecuteCommand/ExecuteCommand.ts
 var executeCommand2 = async (id2, ...args) => {
-  return invoke("Extensions.executeCommand", id2, ...args);
+  return ExtensionManagementWorker_exports.invoke("Extensions.executeCommand", id2, ...args);
 };
 
 // packages/extension-api/src/parts/QuickPick/QuickPick.ts
 var showQuickPick = async (options) => {
-  return invoke("ExtensionHostQuickPick.showQuickPick", options);
+  return ExtensionManagementWorker_exports.invoke("ExtensionHostQuickPick.showQuickPick", options);
 };
 
 // packages/extension-api/src/parts/CommandMap/CommandMap.ts
@@ -1459,17 +2353,24 @@ var handleExtensionManagementMessagePort2 = async ({
 };
 export {
   activate,
+  createOutputChannel,
+  createViewInstance,
+  dispatchViewEvent,
+  disposeViewInstance,
   executeCommand2 as executeCommand,
   executeCompletionProvider,
   executeDiagnosticProvider,
   executeFormattingProvider,
   executeHoverProvider,
   executeResolveCompletionItemProvider,
+  executeViewProvider,
   getCompletionProviderRegistrySnapshot,
   getDiagnosticProviderRegistrySnapshot,
   getFormattingProviderRegistrySnapshot,
   getHoverProviderRegistrySnapshot,
+  getOutputChannelRegistrySnapshot,
   getStatusBarItemProviderRegistrySnapshot,
+  getViewRegistrySnapshot,
   handleExtensionManagementMessagePort2 as handleExtensionManagementMessagePort,
   registerCommand,
   registerCompletionProvider,
@@ -1477,10 +2378,14 @@ export {
   registerFormattingProvider,
   registerHoverProvider,
   registerStatusBarItemProvider,
+  registerView,
   resetCompletionProviderRegistry,
   resetDiagnosticProviderRegistry,
   resetFormattingProviderRegistry,
   resetHoverProviderRegistry,
+  resetOutputChannelRegistry,
   resetStatusBarItemProviderRegistry,
+  resetViewRegistry,
+  saveViewInstanceState,
   showQuickPick
 };