@lvce-editor/extension-host-worker 8.15.0 → 8.17.0

package/dist/extension-api/parts/Activation/Activation.js

@@ -0,0 +1,13 @@
+import { listen } from "../ExtensionApiWorkerListen/ExtensionApiWorkerListen.js";
+import * as Rpc from "../Rpc/Rpc.js";
+let rpcPromise;
+const activate = async () => {
+  if (!rpcPromise) {
+    rpcPromise = listen();
+  }
+  const rpc = await rpcPromise;
+  Rpc.set(rpc);
+};
+export {
+  activate
+};

package/dist/extension-api/parts/AssertCompletionProvider/AssertCompletionProvider.js

@@ -0,0 +1,25 @@
+import { hasCompletionProvider } from "../CompletionProviderState/CompletionProviderState.js";
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const assertCompletionProvider = (provider) => {
+  if (!provider) {
+    throw new ExtensionApiError("completion provider is not defined");
+  }
+  if (!provider.id) {
+    throw new ExtensionApiError("completion provider is missing id");
+  }
+  if (!provider.languageId) {
+    throw new ExtensionApiError(`completion provider ${provider.id} is missing languageId`);
+  }
+  if (typeof provider.provideCompletions !== "function") {
+    throw new ExtensionApiError(`completion provider ${provider.id} is missing provideCompletions function`);
+  }
+  if (provider.resolveCompletionItem !== void 0 && typeof provider.resolveCompletionItem !== "function") {
+    throw new ExtensionApiError(`completion provider ${provider.id} has invalid resolveCompletionItem function`);
+  }
+  if (hasCompletionProvider(provider.id)) {
+    throw new ExtensionApiError(`completion provider ${provider.id} is already registered`);
+  }
+};
+export {
+  assertCompletionProvider
+};

package/dist/extension-api/parts/AssertFormattingProvider/AssertFormattingProvider.js

@@ -0,0 +1,22 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { hasFormattingProvider } from "../FormattingProviderState/FormattingProviderState.js";
+const assertFormattingProvider = (provider) => {
+  if (!provider) {
+    throw new ExtensionApiError("formatting provider is not defined");
+  }
+  if (typeof provider.id !== "string" || provider.id.length === 0) {
+    throw new ExtensionApiError("formatting provider is missing id");
+  }
+  if (typeof provider.languageId !== "string" || provider.languageId.length === 0) {
+    throw new ExtensionApiError(`formatting provider ${provider.id} is missing languageId`);
+  }
+  if (typeof provider.format !== "function") {
+    throw new ExtensionApiError(`formatting provider ${provider.id} is missing format function`);
+  }
+  if (hasFormattingProvider(provider.id)) {
+    throw new ExtensionApiError(`formatting provider ${provider.id} is already registered`);
+  }
+};
+export {
+  assertFormattingProvider
+};

package/dist/extension-api/parts/AssertStatusBarItemProvider/AssertStatusBarItemProvider.js

@@ -0,0 +1,19 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { hasStatusBarItemProvider } from "../StatusBarItemProviderState/StatusBarItemProviderState.js";
+const assertStatusBarItemProvider = (provider) => {
+  if (!provider) {
+    throw new ExtensionApiError("status bar item provider is not defined");
+  }
+  if (typeof provider.id !== "string" || provider.id.length === 0) {
+    throw new ExtensionApiError("status bar item provider is missing id");
+  }
+  if (typeof provider.getStatusBarItem !== "function") {
+    throw new ExtensionApiError(`status bar item provider ${provider.id} is missing getStatusBarItem function`);
+  }
+  if (hasStatusBarItemProvider(provider.id)) {
+    throw new ExtensionApiError(`status bar item provider ${provider.id} is already registered`);
+  }
+};
+export {
+  assertStatusBarItemProvider
+};

package/dist/extension-api/parts/CommandMap/CommandMap.js

@@ -0,0 +1,14 @@
+import { commandMap as extensionApiCommandMap } from "../ExtensionApiCommandMap/ExtensionApiCommandMap.js";
+import { handleExtensionManagementMessagePort } from "../ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.js";
+const commandMap = {
+  ...extensionApiCommandMap,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+export {
+  commandMap
+};

package/dist/extension-api/parts/CommandRegistry/CommandRegistry.js

@@ -0,0 +1,53 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const commands = /* @__PURE__ */ Object.create(null);
+const assertCommand = (command) => {
+  if (!command) {
+    throw new ExtensionApiError("command is not defined");
+  }
+  if (typeof command.id !== "string" || command.id.length === 0) {
+    throw new ExtensionApiError("command is missing id");
+  }
+  if (typeof command.execute !== "function") {
+    throw new ExtensionApiError(`command ${command.id} is missing execute function`);
+  }
+  if (command.id in commands) {
+    throw new ExtensionApiError(`command ${command.id} is already registered`);
+  }
+};
+const registerCommand = (command) => {
+  assertCommand(command);
+  commands[command.id] = {
+    execute(...args) {
+      return command.execute(...args);
+    },
+    id: command.id
+  };
+  return {
+    dispose() {
+      delete commands[command.id];
+    }
+  };
+};
+const getCommandRegistrySnapshot = () => {
+  return {
+    commands: Object.values(commands)
+  };
+};
+const executeCommand = async (id, ...args) => {
+  const command = commands[id];
+  if (!command) {
+    throw new ExtensionApiError(`command ${id} not found`);
+  }
+  return command.execute(...args);
+};
+const resetCommandRegistry = () => {
+  for (const id of Object.keys(commands)) {
+    delete commands[id];
+  }
+};
+export {
+  executeCommand,
+  getCommandRegistrySnapshot,
+  registerCommand,
+  resetCommandRegistry
+};

package/dist/extension-api/parts/Completion/Completion.js

@@ -0,0 +1,11 @@
+import { executeCompletionProvider, executeResolveCompletionItemProvider } from "../ExecuteCompletionProvider/ExecuteCompletionProvider.js";
+import { getCompletionProviderRegistrySnapshot } from "../GetCompletionProviderRegistrySnapshot/GetCompletionProviderRegistrySnapshot.js";
+import { registerCompletionProvider } from "../RegisterCompletionProvider/RegisterCompletionProvider.js";
+import { resetCompletionProviderRegistry } from "../ResetCompletionProviderRegistry/ResetCompletionProviderRegistry.js";
+export {
+  executeCompletionProvider,
+  executeResolveCompletionItemProvider,
+  getCompletionProviderRegistrySnapshot,
+  registerCompletionProvider,
+  resetCompletionProviderRegistry
+};

package/dist/extension-api/parts/CompletionProviderRegistry/CompletionProviderRegistry.js

@@ -0,0 +1,78 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+import { createProviderRegistry } from "../ProviderRegistry/ProviderRegistry.js";
+const getType = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return typeof value;
+};
+const validateCompletionResult = (completion) => {
+  if (!Array.isArray(completion)) {
+    throw new ExtensionApiError(`invalid completion result: completion must be of type array but is ${getType(completion)}`);
+  }
+  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)}`);
+    }
+  }
+  return completion;
+};
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      id: provider.id,
+      languageId: provider.languageId,
+      provideCompletions(textDocument, offset, ...args) {
+        return provider.provideCompletions(textDocument, offset, ...args);
+      },
+      resolveCompletionItem: provider.resolveCompletionItem ? (textDocument, offset, name, completionItem, ...args) => provider.resolveCompletionItem?.(textDocument, offset, name, completionItem, ...args) : void 0
+    };
+  },
+  optionalMethods: ["resolveCompletionItem"],
+  providerName: "completion provider",
+  requiredMethods: ["provideCompletions"],
+  requireLanguageId: true
+});
+const hasCompletionProvider = registry.hasProvider;
+const registerCompletionProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+const executeCompletionProvider = async (textDocument, offset, ...args) => {
+  return registry.executeProviderByLanguageId(
+    textDocument.languageId,
+    "provideCompletions",
+    [textDocument, offset, ...args],
+    validateCompletionResult
+  );
+};
+const executeResolveCompletionItemProvider = async (textDocument, offset, name, completionItem, ...args) => {
+  const provider = registry.getProviderByLanguageId(textDocument.languageId);
+  if (!provider) {
+    throw new ExtensionApiError(`No completion provider found for ${textDocument.languageId}`);
+  }
+  return provider.resolveCompletionItem?.(textDocument, offset, name, completionItem, ...args);
+};
+const getCompletionProviders = registry.getProviders;
+const getCompletionProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+const resetCompletionProviderRegistry = registry.reset;
+export {
+  executeCompletionProvider,
+  executeResolveCompletionItemProvider,
+  getCompletionProviderRegistrySnapshot,
+  getCompletionProviders,
+  hasCompletionProvider,
+  registerCompletionProvider,
+  resetCompletionProviderRegistry
+};

package/dist/extension-api/parts/CompletionProviderState/CompletionProviderState.js

@@ -0,0 +1,10 @@
+import {
+  getCompletionProviders,
+  hasCompletionProvider,
+  resetCompletionProviderRegistry
+} from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  resetCompletionProviderRegistry as clearCompletionProviders,
+  getCompletionProviders,
+  hasCompletionProvider
+};

package/dist/extension-api/parts/ExecuteCommand/ExecuteCommand.js

@@ -0,0 +1,7 @@
+import * as Rpc from "../Rpc/Rpc.js";
+const executeCommand = async (id, ...args) => {
+  return Rpc.invoke("Extensions.executeCommand", id, ...args);
+};
+export {
+  executeCommand
+};

package/dist/extension-api/parts/ExecuteCompletionProvider/ExecuteCompletionProvider.js

@@ -0,0 +1,5 @@
+import { executeCompletionProvider, executeResolveCompletionItemProvider } from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  executeCompletionProvider,
+  executeResolveCompletionItemProvider
+};

package/dist/extension-api/parts/ExecuteFormattingProvider/ExecuteFormattingProvider.js

@@ -0,0 +1,4 @@
+import { executeFormattingProvider } from "../FormattingProviderRegistry/FormattingProviderRegistry.js";
+export {
+  executeFormattingProvider
+};

package/dist/extension-api/parts/ExtensionApiCommandMap/ExtensionApiCommandMap.js

@@ -0,0 +1,17 @@
+import { executeCommand, getCommandRegistrySnapshot } from "../CommandRegistry/CommandRegistry.js";
+import { executeCompletionProvider, executeResolveCompletionItemProvider, getCompletionProviderRegistrySnapshot } from "../Completion/Completion.js";
+import { executeFormattingProvider, getFormattingProviderRegistrySnapshot } from "../Formatting/Formatting.js";
+import { getStatusBarItems } from "../GetStatusBarItems/GetStatusBarItems.js";
+const commandMap = {
+  "ExtensionApi.executeCommand": executeCommand,
+  "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
+  "ExtensionApi.executeFormattingProvider": executeFormattingProvider,
+  "ExtensionApi.executeResolveCompletionItemProvider": executeResolveCompletionItemProvider,
+  "ExtensionApi.getCommandRegistrySnapshot": getCommandRegistrySnapshot,
+  "ExtensionApi.getCompletionProviderRegistrySnapshot": getCompletionProviderRegistrySnapshot,
+  "ExtensionApi.getFormattingProviderRegistrySnapshot": getFormattingProviderRegistrySnapshot,
+  "ExtensionApi.getStatusBarItems": getStatusBarItems
+};
+export {
+  commandMap
+};

package/dist/extension-api/parts/ExtensionApiError/ExtensionApiError.js

@@ -0,0 +1,9 @@
+class ExtensionApiError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExtensionApiError";
+  }
+}
+export {
+  ExtensionApiError
+};

package/dist/extension-api/parts/ExtensionApiWorkerCommandMap/ExtensionApiWorkerCommandMap.js

@@ -0,0 +1,15 @@
+import { commandMap as extensionApiCommandMap } from "../ExtensionApiCommandMap/ExtensionApiCommandMap.js";
+import { handleExtensionManagementMessagePort } from "../ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.js";
+const commandMap = {
+  ...extensionApiCommandMap,
+  "HandleMessagePort.handleExtensionManagementMessagePort": handleExtensionManagementMessagePort,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+export {
+  commandMap
+};

package/dist/extension-api/parts/ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.js

@@ -0,0 +1,21 @@
+import { PlainMessagePortRpc } from "@lvce-editor/rpc";
+import * as ExtensionApiCommandMap from "../ExtensionApiCommandMap/ExtensionApiCommandMap.js";
+const commandMap = {
+  ...ExtensionApiCommandMap.commandMap,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+const handleExtensionManagementMessagePort = async (port) => {
+  await PlainMessagePortRpc.create({
+    commandMap,
+    isMessagePortOpen: true,
+    messagePort: port
+  });
+};
+export {
+  handleExtensionManagementMessagePort
+};

package/dist/extension-api/parts/ExtensionApiWorkerListen/ExtensionApiWorkerListen.js

@@ -0,0 +1,11 @@
+import { WebWorkerRpcClient } from "@lvce-editor/rpc";
+import * as ExtensionApiWorkerCommandMap from "../ExtensionApiWorkerCommandMap/ExtensionApiWorkerCommandMap.js";
+const listen = async () => {
+  const rpc = WebWorkerRpcClient.create({
+    commandMap: ExtensionApiWorkerCommandMap.commandMap
+  });
+  return rpc;
+};
+export {
+  listen
+};

package/dist/extension-api/parts/Formatting/Formatting.js

@@ -0,0 +1,10 @@
+import { executeFormattingProvider } from "../ExecuteFormattingProvider/ExecuteFormattingProvider.js";
+import { getFormattingProviderRegistrySnapshot } from "../GetFormattingProviderRegistrySnapshot/GetFormattingProviderRegistrySnapshot.js";
+import { registerFormattingProvider } from "../RegisterFormattingProvider/RegisterFormattingProvider.js";
+import { resetFormattingProviderRegistry } from "../ResetFormattingProviderRegistry/ResetFormattingProviderRegistry.js";
+export {
+  executeFormattingProvider,
+  getFormattingProviderRegistrySnapshot,
+  registerFormattingProvider,
+  resetFormattingProviderRegistry
+};

package/dist/extension-api/parts/FormattingProviderRegistry/FormattingProviderRegistry.js

@@ -0,0 +1,42 @@
+import { createProviderRegistry } from "../ProviderRegistry/ProviderRegistry.js";
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      format(textDocument, ...args) {
+        return provider.format(textDocument, ...args);
+      },
+      id: provider.id,
+      languageId: provider.languageId
+    };
+  },
+  providerName: "formatting provider",
+  requiredMethods: ["format"],
+  requireLanguageId: true
+});
+const hasFormattingProvider = registry.hasProvider;
+const registerFormattingProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+const executeFormattingProvider = async (textDocument, ...args) => {
+  return registry.executeProviderByLanguageId(textDocument.languageId, "format", [textDocument, ...args]);
+};
+const getFormattingProviders = registry.getProviders;
+const getFormattingProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+const resetFormattingProviderRegistry = registry.reset;
+export {
+  executeFormattingProvider,
+  getFormattingProviderRegistrySnapshot,
+  getFormattingProviders,
+  hasFormattingProvider,
+  registerFormattingProvider,
+  resetFormattingProviderRegistry
+};

package/dist/extension-api/parts/FormattingProviderState/FormattingProviderState.js

@@ -0,0 +1,10 @@
+import {
+  getFormattingProviders,
+  hasFormattingProvider,
+  resetFormattingProviderRegistry
+} from "../FormattingProviderRegistry/FormattingProviderRegistry.js";
+export {
+  resetFormattingProviderRegistry as clearFormattingProviders,
+  getFormattingProviders,
+  hasFormattingProvider
+};

package/dist/extension-api/parts/GetCompletionProviderRegistrySnapshot/GetCompletionProviderRegistrySnapshot.js

@@ -0,0 +1,4 @@
+import { getCompletionProviderRegistrySnapshot } from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  getCompletionProviderRegistrySnapshot
+};

package/dist/extension-api/parts/GetFormattingProviderRegistrySnapshot/GetFormattingProviderRegistrySnapshot.js

@@ -0,0 +1,4 @@
+import { getFormattingProviderRegistrySnapshot } from "../FormattingProviderRegistry/FormattingProviderRegistry.js";
+export {
+  getFormattingProviderRegistrySnapshot
+};

package/dist/extension-api/parts/GetStatusBarItemProviderRegistrySnapshot/GetStatusBarItemProviderRegistrySnapshot.js

@@ -0,0 +1,4 @@
+import { getStatusBarItemProviderRegistrySnapshot } from "../StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.js";
+export {
+  getStatusBarItemProviderRegistrySnapshot
+};

package/dist/extension-api/parts/GetStatusBarItems/GetStatusBarItems.js

@@ -0,0 +1,4 @@
+import { getStatusBarItems } from "../StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.js";
+export {
+  getStatusBarItems
+};

package/dist/extension-api/parts/HandleExtensionManagementMessagePort/HandleExtensionManagementMessagePort.js

@@ -0,0 +1,17 @@
+import { commandMap as extensionApiCommandMap } from "../CommandMap/CommandMap.js";
+const handleExtensionManagementMessagePort = async ({
+  commandMap,
+  createMessagePortRpcClient,
+  port
+}) => {
+  await createMessagePortRpcClient({
+    commandMap: {
+      ...extensionApiCommandMap,
+      ...commandMap
+    },
+    messagePort: port
+  });
+};
+export {
+  handleExtensionManagementMessagePort
+};

package/dist/extension-api/parts/NotifyStatusBarChange/NotifyStatusBarChange.js

@@ -0,0 +1,7 @@
+import * as Rpc from "../Rpc/Rpc.js";
+const notifyStatusBarChange = async (id) => {
+  await Rpc.invoke("StatusBar.handleChange", id);
+};
+export {
+  notifyStatusBarChange
+};

package/dist/extension-api/parts/ProviderRegistry/ProviderRegistry.js

@@ -0,0 +1,95 @@
+import { ExtensionApiError } from "../ExtensionApiError/ExtensionApiError.js";
+const getProviderMethod = (provider, methodName) => {
+  const method = provider[methodName];
+  if (typeof method !== "function") {
+    return void 0;
+  }
+  return method;
+};
+const assertProviderMethod = (provider, providerName, providerId, methodName) => {
+  if (typeof provider[methodName] !== "function") {
+    throw new ExtensionApiError(`${providerName} ${providerId} is missing ${methodName} function`);
+  }
+};
+const assertOptionalProviderMethod = (provider, providerName, providerId, methodName) => {
+  if (provider[methodName] !== void 0 && typeof provider[methodName] !== "function") {
+    throw new ExtensionApiError(`${providerName} ${providerId} has invalid ${methodName} function`);
+  }
+};
+const createProviderRegistry = ({
+  mapProvider,
+  optionalMethods = [],
+  providerName,
+  requiredMethods,
+  requireLanguageId = false
+}) => {
+  const providers = /* @__PURE__ */ Object.create(null);
+  const hasProvider = (id) => {
+    return id in providers;
+  };
+  const registerProvider = (provider) => {
+    if (!provider) {
+      throw new ExtensionApiError(`${providerName} is not defined`);
+    }
+    const providerRecord = provider;
+    const { id } = providerRecord;
+    if (typeof id !== "string" || id.length === 0) {
+      throw new ExtensionApiError(`${providerName} is missing id`);
+    }
+    if (requireLanguageId && (typeof providerRecord.languageId !== "string" || providerRecord.languageId.length === 0)) {
+      throw new ExtensionApiError(`${providerName} ${id} is missing languageId`);
+    }
+    for (const methodName of requiredMethods) {
+      assertProviderMethod(providerRecord, providerName, id, methodName);
+    }
+    for (const methodName of optionalMethods) {
+      assertOptionalProviderMethod(providerRecord, providerName, id, methodName);
+    }
+    if (hasProvider(id)) {
+      throw new ExtensionApiError(`${providerName} ${id} is already registered`);
+    }
+    const registeredProvider = mapProvider(provider);
+    providers[registeredProvider.id] = registeredProvider;
+    return registeredProvider;
+  };
+  const deleteProvider = (id) => {
+    delete providers[id];
+  };
+  const getProviders = () => {
+    return Object.values(providers);
+  };
+  const getProviderByLanguageId = (languageId) => {
+    return getProviders().find((provider) => {
+      return "languageId" in provider && provider.languageId === languageId;
+    });
+  };
+  const reset = () => {
+    for (const id of Object.keys(providers)) {
+      delete providers[id];
+    }
+  };
+  const executeProviderByLanguageId = async (languageId, methodName, args, validateResult) => {
+    const provider = getProviderByLanguageId(languageId);
+    if (!provider) {
+      throw new ExtensionApiError(`No ${providerName} found for ${languageId}`);
+    }
+    const method = getProviderMethod(provider, methodName);
+    if (!method) {
+      throw new ExtensionApiError(`${providerName} ${provider.id} is missing ${methodName} function`);
+    }
+    const result = await method(...args);
+    return validateResult ? validateResult(result) : result;
+  };
+  return {
+    deleteProvider,
+    executeProviderByLanguageId,
+    getProviderByLanguageId,
+    getProviders,
+    hasProvider,
+    registerProvider,
+    reset
+  };
+};
+export {
+  createProviderRegistry
+};

package/dist/extension-api/parts/QuickPick/QuickPick.js

@@ -0,0 +1,7 @@
+import * as Rpc from "../Rpc/Rpc.js";
+const showQuickPick = async (options) => {
+  return Rpc.invoke("ExtensionHostQuickPick.showQuickPick", options);
+};
+export {
+  showQuickPick
+};

package/dist/extension-api/parts/RegisterCompletionProvider/RegisterCompletionProvider.js

@@ -0,0 +1,4 @@
+import { registerCompletionProvider } from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  registerCompletionProvider
+};

package/dist/extension-api/parts/RegisterFormattingProvider/RegisterFormattingProvider.js

@@ -0,0 +1,4 @@
+import { registerFormattingProvider } from "../FormattingProviderRegistry/FormattingProviderRegistry.js";
+export {
+  registerFormattingProvider
+};

package/dist/extension-api/parts/RegisterStatusBarItemProvider/RegisterStatusBarItemProvider.js

@@ -0,0 +1,4 @@
+import { registerStatusBarItemProvider } from "../StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.js";
+export {
+  registerStatusBarItemProvider
+};

package/dist/extension-api/parts/ResetCompletionProviderRegistry/ResetCompletionProviderRegistry.js

@@ -0,0 +1,4 @@
+import { resetCompletionProviderRegistry } from "../CompletionProviderRegistry/CompletionProviderRegistry.js";
+export {
+  resetCompletionProviderRegistry
+};